Implemented comprehensive enhancements: removed TTS, fixed session state issues, improved UI/UX, added analytics, input validation, and feedback collection

app.py

@@ -43,10 +43,6 @@ if "ngrok_url_temp" not in st.session_state:
     st.session_state.ngrok_url_temp = st.session_state.get("ngrok_url", "https://7bcc180dffd1.ngrok-free.app")
 if "hf_expert_requested" not in st.session_state:
     st.session_state.hf_expert_requested = False
-if "tts_enabled" not in st.session_state:
-    st.session_state.tts_enabled = False
-if "voice_input" not in st.session_state:
-    st.session_state.voice_input = ""
 
 # Sidebar layout redesign
 with st.sidebar:
@@ -153,22 +149,47 @@ with st.sidebar:
                      use_container_width=True,
                      disabled=st.session_state.is_processing):
             st.session_state.hf_expert_requested = True
+            
+        st.divider()
+        st.subheader("🐛 Debug Info")
+        # Show current configuration
+        st.markdown(f"**Environment:** {'HF Space' if config.is_hf_space else 'Local'}")
+        st.markdown(f"**Model:** {st.session_state.selected_model}")
+        st.markdown(f"**Ollama URL:** {st.session_state.ngrok_url_temp}")
+        
+        # Show active features
+        features = []
+        if config.hf_token:
+            features.append("HF Expert")
+        if os.getenv("TAVILY_API_KEY"):
+            features.append("Web Search")
+        if config.openweather_api_key:
+            features.append("Weather")
+        
+        st.markdown(f"**Active Features:** {', '.join(features) if features else 'None'}")
 
 # Main interface
 st.title("🧠 AI Life Coach")
 st.markdown("Ask me anything about personal development, goal setting, or life advice!")
 
+# Consistent message rendering function
+def render_message(role, content, timestamp=None):
+    """Render chat messages with consistent styling"""
+    with st.chat_message(role):
+        if role == "assistant" and content.startswith("### 🤖 HF Expert Analysis"):
+            st.markdown(content)
+        else:
+            st.markdown(content)
+        if timestamp:
+            st.caption(f"🕒 {timestamp}")
+
 # Display messages
 for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        # Format HF expert messages differently
-        if message.get("source") == "hf_expert":
-            st.markdown("### 🤖 HF Expert Analysis")
-            st.markdown(message["content"])
-        else:
-            st.markdown(message["content"])
-        if "timestamp" in message:
-            st.caption(f"🕒 {message['timestamp']}")
+    render_message(
+        message["role"], 
+        message["content"], 
+        message.get("timestamp")
+    )
 
 # Manual HF Analysis Section
 if st.session_state.messages and len(st.session_state.messages) > 0:
@@ -256,105 +277,137 @@ if st.session_state.get("hf_expert_requested", False):
             st.error(f"❌ HF Expert analysis failed: {user_msg}")
             st.session_state.hf_expert_requested = False
 
+# Input validation function
+def validate_user_input(text):
+    """Validate and sanitize user input"""
+    if not text or not text.strip():
+        return False, "Input cannot be empty"
+        
+    if len(text) > 1000:
+        return False, "Input too long (max 1000 characters)"
+        
+    # Check for potentially harmful patterns
+    harmful_patterns = ["<script", "javascript:", "onload=", "onerror="]
+    if any(pattern in text.lower() for pattern in harmful_patterns):
+        return False, "Potentially harmful input detected"
+        
+    return True, text.strip()
+
 # Chat input - FIXED VERSION (moved outside of tabs)
 user_input = st.chat_input("Type your message here...", disabled=st.session_state.is_processing)
 
 # Process message when received
 if user_input and not st.session_state.is_processing:
-    st.session_state.is_processing = True
-    
-    # Display user message
-    with st.chat_message("user"):
-        st.markdown(user_input)
-    
-    # Add to message history - ensure proper format
-    st.session_state.messages.append({
-        "role": "user",
-        "content": user_input,
-        "timestamp": datetime.now().strftime("%H:%M:%S")
-    })
-    
-    # Process AI response
-    with st.chat_message("assistant"):
-        response_placeholder = st.empty()
-        status_placeholder = st.empty()
+    # Validate input
+    is_valid, validated_input = validate_user_input(user_input)
+    if not is_valid:
+        st.error(validated_input)
+        st.session_state.is_processing = False
+    else:
+        st.session_state.is_processing = True
         
-        try:
-            # Get conversation history
-            user_session = session_manager.get_session("default_user")
-            conversation = user_session.get("conversation", [])
-            conversation_history = conversation[-5:]  # Last 5 messages
-            conversation_history.append({"role": "user", "content": user_input})
-            
-            # Try Ollama with proper error handling
-            status_placeholder.info(PROCESSING_STAGES["ollama"])
-            ai_response = None
+        # Display user message
+        with st.chat_message("user"):
+            st.markdown(validated_input)
+        
+        # Add to message history - ensure proper format
+        st.session_state.messages.append({
+            "role": "user",
+            "content": validated_input,
+            "timestamp": datetime.now().strftime("%H:%M:%S")
+        })
+        
+        # Process AI response
+        with st.chat_message("assistant"):
+            response_placeholder = st.empty()
+            status_placeholder = st.empty()
             
             try:
-                ai_response = send_to_ollama(
-                    user_input,
-                    conversation_history,
-                    st.session_state.ngrok_url_temp,
-                    st.session_state.selected_model
-                )
+                # Get conversation history
+                user_session = session_manager.get_session("default_user")
+                conversation = user_session.get("conversation", [])
+                conversation_history = conversation[-5:]  # Last 5 messages
+                conversation_history.append({"role": "user", "content": validated_input})
+                
+                # Try Ollama with proper error handling
+                status_placeholder.info(PROCESSING_STAGES["ollama"])
+                ai_response = None
                 
-                if ai_response:
-                    response_placeholder.markdown(ai_response)
-                    status_placeholder.success("✅ Response received!")
-                else:
-                    status_placeholder.warning("⚠️ Empty response from Ollama")
-            
-            except Exception as ollama_error:
-                user_msg = translate_error(ollama_error)
-                status_placeholder.error(f"⚠️ {user_msg}")
-            
-            # Fallback to HF if available
-            if config.hf_token and not ai_response:
-                status_placeholder.info(PROCESSING_STAGES["hf_init"])
                 try:
-                    ai_response = send_to_hf(user_input, conversation_history)
+                    ai_response = send_to_ollama(
+                        validated_input,
+                        conversation_history,
+                        st.session_state.ngrok_url_temp,
+                        st.session_state.selected_model
+                    )
+                    
                     if ai_response:
                         response_placeholder.markdown(ai_response)
-                        status_placeholder.success("✅ HF response received!")
+                        status_placeholder.success("✅ Response received!")
                     else:
-                        status_placeholder.error("❌ No response from HF")
-                except Exception as hf_error:
-                    user_msg = translate_error(hf_error)
+                        status_placeholder.warning("⚠️ Empty response from Ollama")
+                
+                except Exception as ollama_error:
+                    user_msg = translate_error(ollama_error)
                     status_placeholder.error(f"⚠️ {user_msg}")
-            
-            # Save response if successful
-            if ai_response:
-                # Update conversation history
-                conversation.append({"role": "user", "content": user_input})
-                conversation.append({"role": "assistant", "content": ai_response})
-                user_session["conversation"] = conversation
-                session_manager.update_session("default_user", user_session)
                 
-                # Add to message history - ensure proper format
-                st.session_state.messages.append({
-                    "role": "assistant",
-                    "content": ai_response,
-                    "timestamp": datetime.now().strftime("%H:%M:%S")
-                })
-            else:
+                # Fallback to HF if available
+                if config.hf_token and not ai_response:
+                    status_placeholder.info(PROCESSING_STAGES["hf_init"])
+                    try:
+                        ai_response = send_to_hf(validated_input, conversation_history)
+                        if ai_response:
+                            response_placeholder.markdown(ai_response)
+                            status_placeholder.success("✅ HF response received!")
+                        else:
+                            status_placeholder.error("❌ No response from HF")
+                    except Exception as hf_error:
+                        user_msg = translate_error(hf_error)
+                        status_placeholder.error(f"⚠️ {user_msg}")
+                
+                # Save response if successful
+                if ai_response:
+                    # Update conversation history
+                    conversation.append({"role": "user", "content": validated_input})
+                    conversation.append({"role": "assistant", "content": ai_response})
+                    user_session["conversation"] = conversation
+                    session_manager.update_session("default_user", user_session)
+                    
+                    # Add to message history - ensure proper format
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": ai_response,
+                        "timestamp": datetime.now().strftime("%H:%M:%S")
+                    })
+                    
+                    # Add feedback buttons
+                    st.divider()
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        if st.button("👍 Helpful", key=f"helpful_{len(st.session_state.messages)}"):
+                            st.success("Thanks for your feedback!")
+                    with col2:
+                        if st.button("👎 Not Helpful", key=f"not_helpful_{len(st.session_state.messages)}"):
+                            st.success("Thanks for your feedback!")
+                else:
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": "Sorry, I couldn't process your request. Please try again.",
+                        "timestamp": datetime.now().strftime("%H:%M:%S")
+                    })
+            
+            except Exception as e:
+                user_msg = translate_error(e)
+                response_placeholder.error(f"⚠️ {user_msg}")
                 st.session_state.messages.append({
                     "role": "assistant",
-                    "content": "Sorry, I couldn't process your request. Please try again.",
+                    "content": f"⚠️ {user_msg}",
                     "timestamp": datetime.now().strftime("%H:%M:%S")
                 })
-        
-        except Exception as e:
-            user_msg = translate_error(e)
-            response_placeholder.error(f"⚠️ {user_msg}")
-            st.session_state.messages.append({
-                "role": "assistant",
-                "content": f"⚠️ {user_msg}",
-                "timestamp": datetime.now().strftime("%H:%M:%S")
-            })
-        finally:
-            st.session_state.is_processing = False
-            time.sleep(0.5)  # Brief pause
-            st.experimental_rerun()
+            finally:
+                st.session_state.is_processing = False
+                time.sleep(0.5)  # Brief pause
+                st.experimental_rerun()
 
 # Add evaluation dashboard tab (separate from chat interface)
 st.divider()
@@ -408,20 +461,20 @@ with tab1:
                 research_keywords = ["study", "research", "paper", "effectiveness", "clinical trial", "vitamin", "drug", "metformin", "CRISPR"]
                 if any(kw in final_prompt.lower() for kw in research_keywords):
                     st.markdown("**Related Research Papers:**")
-                    with st.spinner("Searching for academic papers..."):
+                    with st.spinner("Searching academic databases..."):
                         try:
                             papers = find_papers(final_prompt, limit=3)
                             if papers:
                                 for i, paper in enumerate(papers):
-                                    with st.expander(f"📄 {paper['title'][:50]}{'...' if len(paper['title']) > 50 else ''}"):
+                                    with st.expander(f"📄 {paper['title'][:60]}..."):
                                         st.markdown(f"**Authors:** {', '.join(paper['authors'][:3])}")
                                         st.markdown(f"**Year:** {paper['year']}")
                                         st.markdown(f"**Citations:** {paper['citation_count']}")
                                         st.markdown(f"**Venue:** {paper['venue']}")
-                                        st.markdown(f"**Abstract:** {paper['abstract'][:300]}{'...' if len(paper['abstract']) > 300 else ''}")
-                                        st.markdown(f"[View Paper]({paper['url']})")
+                                        st.markdown(f"**Abstract:** {paper['abstract'][:200]}...")
+                                        st.markdown(f"[View Full Paper]({paper['url']})")
                             else:
-                                st.info("No relevant papers found for this topic.")
+                                st.info("No relevant academic papers found for this topic.")
                         except Exception as e:
                             st.warning(f"Could not fetch research papers: {translate_error(e)}")
 
@@ -512,6 +565,36 @@ with tab2:
         features.append("Weather Data")
     
     st.markdown(f"**Active Features:** {', '.join(features) if features else 'None'}")
+    
+    # Conversation Analytics
+    st.subheader("📊 Conversation Analytics")
+    try:
+        user_session = session_manager.get_session("default_user")
+        conversation = user_session.get("conversation", [])
+        
+        if conversation:
+            # Analyze conversation patterns
+            user_messages = [msg for msg in conversation if msg["role"] == "user"]
+            ai_messages = [msg for msg in conversation if msg["role"] == "assistant"]
+            
+            col1, col2, col3 = st.columns(3)
+            col1.metric("Total Exchanges", len(user_messages))
+            col2.metric("Avg Response Length", 
+                       round(sum(len(msg.get("content", "")) for msg in ai_messages) / len(ai_messages)) if ai_messages else 0)
+            col3.metric("Topics Discussed", len(set(["life", "goal", "health", "career"]) &
+                                               set(" ".join([msg.get("content", "") for msg in conversation]).lower().split())))
+            
+            # Show most common words/topics
+            all_text = " ".join([msg.get("content", "") for msg in conversation]).lower()
+            common_words = ["life", "goal", "health", "career", "productivity", "mindfulness"]
+            relevant_topics = [word for word in common_words if word in all_text]
+            if relevant_topics:
+                st.markdown(f"**Detected Topics:** {', '.join(relevant_topics)}")
+        else:
+            st.info("No conversation data available yet.")
+            
+    except Exception as e:
+        st.warning(f"Could not analyze conversation: {translate_error(e)}")
 
 with tab3:
     st.header("ℹ️ About AI Life Coach")

requirements.txt

@@ -11,7 +11,3 @@ pygame==2.5.2
 pydantic==1.10.7
 typing-extensions>=4.5.0
 semanticscholar>=0.1.8
-semanticscholar>=0.1.8
-tavily-python>=0.1.0,<1.0.0
-semanticscholar>=0.1.8
-tavily-python>=0.1.0,<1.0.0

services/tts.py

@@ -1,88 +0,0 @@
-import os
-import requests
-from typing import Optional
-from utils.config import config
-
-class TTSService:
-    """Service for converting text to speech"""
-    
-    def __init__(self):
-        self.hf_token = config.hf_token
-        self.tts_model = "facebook/fastspeech2-en-ljspeech"
-        self.vocoder_model = "facebook/hifigan-universal"
-        
-    def synthesize_speech(self, text: str) -> Optional[bytes]:
-        """
-        Convert text to speech using Hugging Face API
-        
-        Args:
-            text: Text to convert to speech
-            
-        Returns:
-            Audio bytes or None if failed
-        """
-        if not self.hf_token:
-            print("Hugging Face token not configured for TTS")
-            return None
-            
-        try:
-            # First, generate speech with text-to-speech model
-            tts_headers = {
-                "Authorization": f"Bearer {self.hf_token}"
-            }
-            
-            tts_payload = {
-                "inputs": text
-            }
-            
-            tts_response = requests.post(
-                f"https://api-inference.huggingface.co/models/{self.tts_model}",
-                headers=tts_headers,
-                json=tts_payload
-            )
-            
-            if tts_response.status_code != 200:
-                print(f"TTS model error: {tts_response.status_code} - {tts_response.text}")
-                return None
-                
-            # Then, convert to audio with vocoder
-            vocoder_response = requests.post(
-                f"https://api-inference.huggingface.co/models/{self.vocoder_model}",
-                headers=tts_headers,
-                data=tts_response.content
-            )
-            
-            if vocoder_response.status_code == 200:
-                return vocoder_response.content
-            else:
-                print(f"Vocoder error: {vocoder_response.status_code} - {vocoder_response.text}")
-                return None
-                
-        except Exception as e:
-            print(f"Error synthesizing speech: {e}")
-            return None
-    
-    def save_audio_file(self, text: str, filename: str) -> bool:
-        """
-        Synthesize speech and save to file
-        
-        Args:
-            text: Text to convert to speech
-            filename: Output filename (.wav)
-            
-        Returns:
-            Boolean indicating success
-        """
-        audio_data = self.synthesize_speech(text)
-        if audio_data:
-            try:
-                with open(filename, 'wb') as f:
-                    f.write(audio_data)
-                return True
-            except Exception as e:
-                print(f"Error saving audio file: {e}")
-                return False
-        return False
-
-# Global TTS service instance
-tts_service = TTSService()