Implemented live web search (Tavily), academic research access (Semantic Scholar), and evaluation dashboard with tabs

AI-Life-Coach-Streamlit2

@@ -0,0 +1 @@
+Subproject commit ac83e06dd776b60459bb531d961b4f327d1e6a41

app.py

@@ -14,6 +14,7 @@ from core.session import session_manager
 from core.memory import check_redis_health
 from core.coordinator import coordinator
 from core.errors import translate_error
+from services.research.papers import find_papers
 import logging
 
 # Set up logging
@@ -43,312 +44,469 @@ if "ngrok_url_temp" not in st.session_state:
 if "hf_expert_requested" not in st.session_state:
     st.session_state.hf_expert_requested = False
 
-# Sidebar layout redesign
-with st.sidebar:
-    st.title("🧠 AI Life Coach")
-    st.markdown("Your personal AI-powered life development assistant")
-    
-    # PRIMARY ACTIONS
-    st.subheader("💬 Primary Actions")
-    model_options = {
-        "Mistral 7B (Local)": "mistral:latest",
-        "Llama 2 7B (Local)": "llama2:latest",
-        "OpenChat 3.5 (Local)": "openchat:latest"
-    }
-    selected_model_name = st.selectbox(
-        "Select Model",
-        options=list(model_options.keys()),
-        index=0,
-        key="sidebar_model_select"
-    )
-    st.session_state.selected_model = model_options[selected_model_name]
-    
-    st.divider()
-    
-    # CONFIGURATION
-    st.subheader("⚙️ Configuration")
-    ngrok_url_input = st.text_input(
-        "Ollama Server URL",
-        value=st.session_state.ngrok_url_temp,
-        help="Enter your ngrok URL",
-        key="sidebar_ngrok_url"
-    )
-    
-    if ngrok_url_input != st.session_state.ngrok_url_temp:
-        st.session_state.ngrok_url_temp = ngrok_url_input
-        st.success("✅ URL updated!")
-    
-    if st.button("📡 Test Connection"):
-        try:
-            import requests
-            headers = {
-                "ngrok-skip-browser-warning": "true",
-                "User-Agent": "AI-Life-Coach-Test"
-            }
-            with st.spinner("Testing connection..."):
-                response = requests.get(
-                    f"{ngrok_url_input}/api/tags",
-                    headers=headers,
-                    timeout=15
-                )
-                if response.status_code == 200:
-                    st.success("✅ Connection successful!")
-                else:
-                    st.error(f"❌ Failed: {response.status_code}")
-        except Exception as e:
-            st.error(f"❌ Error: {str(e)[:50]}...")
-    
-    if st.button("🗑️ Clear History"):
-        st.session_state.messages = []
-        st.success("History cleared!")
-    
-    st.divider()
-    
-    # ADVANCED FEATURES
-    with st.expander("🔍 Advanced Features", expanded=False):
-        st.subheader("📊 System Monitor")
-        try:
-            from services.ollama_monitor import check_ollama_status
-            ollama_status = check_ollama_status()
-            if ollama_status.get("running"):
-                st.success("🦙 Ollama: Running")
-            else:
-                st.warning("🦙 Ollama: Not running")
-        except:
-            st.info("🦙 Ollama: Unknown")
+# Add evaluation dashboard tab
+tab1, tab2, tab3 = st.tabs(["💬 Chat", "🔬 Evaluate AI", "📊 Reports"])
+
+with tab1:
+    # Sidebar layout redesign
+    with st.sidebar:
+        st.title("🧠 AI Life Coach")
+        st.markdown("Your personal AI-powered life development assistant")
         
-        try:
-            from services.hf_endpoint_monitor import hf_monitor
-            hf_status = hf_monitor.check_endpoint_status()
-            if hf_status['available']:
-                st.success("🤗 HF: Available")
-            else:
-                st.warning("🤗 HF: Not available")
-        except:
-            st.info("🤗 HF: Unknown")
+        # PRIMARY ACTIONS
+        st.subheader("💬 Primary Actions")
+        model_options = {
+            "Mistral 7B (Local)": "mistral:latest",
+            "Llama 2 7B (Local)": "llama2:latest",
+            "OpenChat 3.5 (Local)": "openchat:latest"
+        }
+        selected_model_name = st.selectbox(
+            "Select Model",
+            options=list(model_options.keys()),
+            index=0,
+            key="sidebar_model_select"
+        )
+        st.session_state.selected_model = model_options[selected_model_name]
         
-        if check_redis_health():
-            st.success("💾 Redis: Connected")
-        else:
-            st.error("💾 Redis: Disconnected")
+        st.divider()
+        
+        # CONFIGURATION
+        st.subheader("⚙️ Configuration")
+        ngrok_url_input = st.text_input(
+            "Ollama Server URL",
+            value=st.session_state.ngrok_url_temp,
+            help="Enter your ngrok URL",
+            key="sidebar_ngrok_url"
+        )
+        
+        if ngrok_url_input != st.session_state.ngrok_url_temp:
+            st.session_state.ngrok_url_temp = ngrok_url_input
+            st.success("✅ URL updated!")
+        
+        if st.button("📡 Test Connection"):
+            try:
+                import requests
+                headers = {
+                    "ngrok-skip-browser-warning": "true",
+                    "User-Agent": "AI-Life-Coach-Test"
+                }
+                with st.spinner("Testing connection..."):
+                    response = requests.get(
+                        f"{ngrok_url_input}/api/tags",
+                        headers=headers,
+                        timeout=15
+                    )
+                    if response.status_code == 200:
+                        st.success("✅ Connection successful!")
+                    else:
+                        st.error(f"❌ Failed: {response.status_code}")
+            except Exception as e:
+                st.error(f"❌ Error: {str(e)[:50]}...")
+        
+        if st.button("🗑️ Clear History"):
+            st.session_state.messages = []
+            st.success("History cleared!")
         
         st.divider()
         
-        st.subheader("🤖 HF Expert Analysis")
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            st.markdown("""
-                **HF Expert Features:**
-                - Analyzes entire conversation history
-                - Performs web research when needed
-                - Provides deep insights and recommendations
-                - Acts as expert consultant in your conversation
-            """)
-        with col2:
-            if st.button("🧠 Activate HF Expert",
-                         key="activate_hf_expert_sidebar",
-                         help="Send conversation to HF endpoint for deep analysis",
-                         use_container_width=True,
-                         disabled=st.session_state.is_processing):
-                st.session_state.hf_expert_requested = True
+        # ADVANCED FEATURES
+        with st.expander("🔍 Advanced Features", expanded=False):
+            st.subheader("📊 System Monitor")
+            try:
+                from services.ollama_monitor import check_ollama_status
+                ollama_status = check_ollama_status()
+                if ollama_status.get("running"):
+                    st.success("🦙 Ollama: Running")
+                else:
+                    st.warning("🦙 Ollama: Not running")
+            except:
+                st.info("🦙 Ollama: Unknown")
+            
+            try:
+                from services.hf_endpoint_monitor import hf_monitor
+                hf_status = hf_monitor.check_endpoint_status()
+                if hf_status['available']:
+                    st.success("🤗 HF: Available")
+                else:
+                    st.warning("🤗 HF: Not available")
+            except:
+                st.info("🤗 HF: Unknown")
+            
+            if check_redis_health():
+                st.success("💾 Redis: Connected")
+            else:
+                st.error("💾 Redis: Disconnected")
+            
+            st.divider()
+            
+            st.subheader("🤖 HF Expert Analysis")
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.markdown("""
+                    **HF Expert Features:**
+                    - Analyzes entire conversation history
+                    - Performs web research when needed
+                    - Provides deep insights and recommendations
+                    - Acts as expert consultant in your conversation
+                """)
+            with col2:
+                if st.button("🧠 Activate HF Expert",
+                             key="activate_hf_expert_sidebar",
+                             help="Send conversation to HF endpoint for deep analysis",
+                             use_container_width=True,
+                             disabled=st.session_state.is_processing):
+                    st.session_state.hf_expert_requested = True
 
-# Main interface
-st.title("🧠 AI Life Coach")
-st.markdown("Ask me anything about personal development, goal setting, or life advice!")
+    # Main interface
+    st.title("🧠 AI Life Coach")
+    st.markdown("Ask me anything about personal development, goal setting, or life advice!")
 
-# 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']}")
+    # 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']}")
 
-# Manual HF Analysis Section
-if st.session_state.messages and len(st.session_state.messages) > 0:
-    st.divider()
-    
-    # HF Expert Section
-    with st.expander("�� HF Expert Analysis", expanded=False):
-        st.subheader("Deep Conversation Analysis")
+    # Manual HF Analysis Section
+    if st.session_state.messages and len(st.session_state.messages) > 0:
+        st.divider()
         
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            st.markdown("""
-                **HF Expert Features:**
-                - Analyzes entire conversation history
-                - Performs web research when needed
-                - Provides deep insights and recommendations
-                - Acts as expert consultant in your conversation
-            """)
+        # HF Expert Section
+        with st.expander("🤖 HF Expert Analysis", expanded=False):
+            st.subheader("Deep Conversation Analysis")
             
-            # Show conversation preview
-            st.markdown("**Conversation Preview for HF Expert:**")
-            st.markdown("---")
-            for i, msg in enumerate(st.session_state.messages[-5:]):  # Last 5 messages
-                role = "👤 You" if msg["role"] == "user" else "🤖 Assistant"
-                st.markdown(f"**{role}:** {msg['content'][:100]}{'...' if len(msg['content']) > 100 else ''}")
-            st.markdown("---")
-        
-        with col2:
-            if st.button("🧠 Activate HF Expert",
-                         key="activate_hf_expert",
-                         help="Send conversation to HF endpoint for deep analysis",
-                         use_container_width=True,
-                         disabled=st.session_state.is_processing):
-                st.session_state.hf_expert_requested = True
-        
-        # Show HF expert analysis when requested
-        if st.session_state.get("hf_expert_requested", False):
-            with st.spinner("🧠 HF Expert analyzing conversation..."):
-                try:
-                    # Get conversation history
-                    user_session = session_manager.get_session("default_user")
-                    conversation_history = user_session.get("conversation", [])
-                    
-                    # Show what HF expert sees
-                    with st.expander("📋 HF Expert Input", expanded=False):
-                        st.markdown("**Conversation History Sent to HF Expert:**")
-                        for i, msg in enumerate(conversation_history[-10:]):  # Last 10 messages
-                            st.markdown(f"**{msg['role'].capitalize()}:** {msg['content'][:100]}{'...' if len(msg['content']) > 100 else ''}")
-                    
-                    # Request HF analysis
-                    hf_analysis = coordinator.manual_hf_analysis(
-                        "default_user",
-                        conversation_history
-                    )
-                    
-                    if hf_analysis:
-                        # Display HF expert response with clear indication
-                        with st.chat_message("assistant"):
-                            st.markdown("### 🤖 HF Expert Analysis")
-                            st.markdown(hf_analysis)
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.markdown("""
+                    **HF Expert Features:**
+                    - Analyzes entire conversation history
+                    - Performs web research when needed
+                    - Provides deep insights and recommendations
+                    - Acts as expert consultant in your conversation
+                """)
+                
+                # Show conversation preview
+                st.markdown("**Conversation Preview for HF Expert:**")
+                st.markdown("---")
+                for i, msg in enumerate(st.session_state.messages[-5:]):  # Last 5 messages
+                    role = "👤 You" if msg["role"] == "user" else "🤖 Assistant"
+                    st.markdown(f"**{role}:** {msg['content'][:100]}{'...' if len(msg['content']) > 100 else ''}")
+                st.markdown("---")
+            
+            with col2:
+                if st.button("🧠 Activate HF Expert",
+                             key="activate_hf_expert",
+                             help="Send conversation to HF endpoint for deep analysis",
+                             use_container_width=True,
+                             disabled=st.session_state.is_processing):
+                    st.session_state.hf_expert_requested = True
+            
+            # Show HF expert analysis when requested
+            if st.session_state.get("hf_expert_requested", False):
+                with st.spinner("🧠 HF Expert analyzing conversation..."):
+                    try:
+                        # Get conversation history
+                        user_session = session_manager.get_session("default_user")
+                        conversation_history = user_session.get("conversation", [])
                         
-                        # Add research/web search decisions
-                        research_needs = coordinator.determine_web_search_needs(conversation_history)
-                        if research_needs["needs_search"]:
-                            st.info(f"🔍 **Research Needed:** {research_needs['reasoning']}")
-                            if st.button("🔎 Perform Web Research", key="web_research_button"):
-                                # Perform web search
-                                with st.spinner("🔎 Searching for current information..."):
-                                    # Add web search logic here
-                                    st.success("✅ Web research completed!")
+                        # Show what HF expert sees
+                        with st.expander("📋 HF Expert Input", expanded=False):
+                            st.markdown("**Conversation History Sent to HF Expert:**")
+                            for i, msg in enumerate(conversation_history[-10:]):  # Last 10 messages
+                                st.markdown(f"**{msg['role'].capitalize()}:** {msg['content'][:100]}{'...' if len(msg['content']) > 100 else ''}")
                         
-                        # Add to message history with HF expert tag
-                        st.session_state.messages.append({
-                            "role": "assistant",
-                            "content": hf_analysis,
-                            "timestamp": datetime.now().strftime("%H:%M:%S"),
-                            "source": "hf_expert",
-                            "research_needs": research_needs
-                        })
+                        # Request HF analysis
+                        hf_analysis = coordinator.manual_hf_analysis(
+                            "default_user",
+                            conversation_history
+                        )
                         
+                        if hf_analysis:
+                            # Display HF expert response with clear indication
+                            with st.chat_message("assistant"):
+                                st.markdown("### 🤖 HF Expert Analysis")
+                                st.markdown(hf_analysis)
+                            
+                            # Add research/web search decisions
+                            research_needs = coordinator.determine_web_search_needs(conversation_history)
+                            if research_needs["needs_search"]:
+                                st.info(f"🔍 **Research Needed:** {research_needs['reasoning']}")
+                                if st.button("🔎 Perform Web Research", key="web_research_button"):
+                                    # Perform web search
+                                    with st.spinner("🔎 Searching for current information..."):
+                                        # Add web search logic here
+                                        st.success("✅ Web research completed!")
+                            
+                            # Add to message history with HF expert tag
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": hf_analysis,
+                                "timestamp": datetime.now().strftime("%H:%M:%S"),
+                                "source": "hf_expert",
+                                "research_needs": research_needs
+                            })
+                            
+                            st.session_state.hf_expert_requested = False
+                    
+                    except Exception as e:
+                        user_msg = translate_error(e)
+                        st.error(f"❌ HF Expert analysis failed: {user_msg}")
                         st.session_state.hf_expert_requested = False
-                
-                except Exception as e:
-                    user_msg = translate_error(e)
-                    st.error(f"❌ HF Expert analysis failed: {user_msg}")
-                    st.session_state.hf_expert_requested = False
 
-# Chat input - FIXED VERSION
-user_input = st.chat_input("Type your message here...", disabled=st.session_state.is_processing)
+    # Chat input - FIXED VERSION
+    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)
-    
-    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()
+    # Process message when received
+    if user_input and not st.session_state.is_processing:
+        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(user_input)
+        
+        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()
             
             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": user_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(
+                        user_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
+                # 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)
+                        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": 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
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": ai_response,
+                        "timestamp": datetime.now().strftime("%H:%M:%S")
+                    })
+                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": ai_response,
+                    "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()
+
+with tab2:
+    st.header("🔬 AI Behavior Evaluator")
+    st.markdown("Run sample prompts to observe AI behavior.")
+
+    eval_prompts = [
+        "What is the capital of France?",
+        "What day is it today?",
+        "Tell me about recent climate policy changes.",
+        "Explain CRISPR gene editing simply.",
+        "Can vitamin D prevent flu infections?"
+    ]
+
+    selected_prompt = st.selectbox("Choose a test prompt:", eval_prompts)
+    custom_prompt = st.text_input("Or enter your own:", "")
+
+    final_prompt = custom_prompt or selected_prompt
+
+    if st.button("Evaluate"):
+        with st.spinner("Running evaluation..."):
+            start_time = time.time()
+
+            # Simulate sending to coordinator
+            from core.session import session_manager
+            user_session = session_manager.get_session("eval_user")
+            history = user_session.get("conversation", [])
+
+            try:
+                ai_response = send_to_ollama(final_prompt, history, st.session_state.ngrok_url_temp, st.session_state.selected_model)
+                duration = round(time.time() - start_time, 2)
+
+                st.success(f"✅ Response generated in {duration}s")
+                st.markdown("**Response:**")
+                st.write(ai_response)
+
+                st.markdown("**Analysis Tags:**")
+                tags = []
+                if "today" in final_prompt.lower() or "date" in final_prompt.lower():
+                    tags.append("📅 Date Awareness")
+                if any(word in final_prompt.lower() for word in ["news", "latest", "breaking"]):
+                    tags.append("🌐 Web Search Needed")
+                if any(word in final_prompt.lower() for word in ["vitamin", "drug", "metformin", "CRISPR"]):
+                    tags.append("🧬 Scientific Knowledge")
+                st.write(", ".join(tags) if tags else "General Knowledge")
+                
+                # Show research papers if scientific topic
+                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..."):
+                        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 ''}"):
+                                        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']})")
+                            else:
+                                st.info("No relevant papers found for this topic.")
+                        except Exception as e:
+                            st.warning(f"Could not fetch research papers: {translate_error(e)}")
+
+            except Exception as e:
+                st.error(f"Evaluation failed: {translate_error(e)}")
+
+with tab3:
+    st.header("📊 Performance Reports")
+    st.markdown("System performance metrics and usage analytics.")
+    
+    # System status
+    st.subheader("System Status")
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        try:
+            from services.ollama_monitor import check_ollama_status
+            ollama_status = check_ollama_status()
+            if ollama_status.get("running"):
+                st.success("🦙 Ollama: Running")
             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")
-                })
+                st.warning("🦙 Ollama: Not running")
+        except:
+            st.info("🦙 Ollama: Unknown")
+    
+    with col2:
+        try:
+            from services.hf_endpoint_monitor import hf_monitor
+            hf_status = hf_monitor.check_endpoint_status()
+            if hf_status['available']:
+                st.success("🤗 HF: Available")
+            else:
+                st.warning("🤗 HF: Not available")
+        except:
+            st.info("🤗 HF: Unknown")
+    
+    with col3:
+        if check_redis_health():
+            st.success("💾 Redis: Connected")
+        else:
+            st.error("💾 Redis: Disconnected")
+    
+    # Session statistics
+    st.subheader("Session Statistics")
+    try:
+        user_session = session_manager.get_session("default_user")
+        conversation = user_session.get("conversation", [])
+        st.metric("Total Messages", len(conversation))
         
-        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()
+        coord_stats = user_session.get('ai_coordination', {})
+        if coord_stats:
+            st.metric("AI Requests Processed", coord_stats.get('requests_processed', 0))
+            st.metric("Ollama Responses", coord_stats.get('ollama_responses', 0))
+            st.metric("HF Responses", coord_stats.get('hf_responses', 0))
+        else:
+            st.info("No coordination statistics available yet.")
+    except Exception as e:
+        st.warning(f"Could not load session statistics: {translate_error(e)}")
+    
+    # Recent activity
+    st.subheader("Recent Activity")
+    try:
+        recent_activities = coordinator.get_recent_activities("default_user")
+        if recent_activities and recent_activities.get('last_request'):
+            st.markdown(f"**Last Request:** {recent_activities['last_request']}")
+            st.markdown(f"**Requests Processed:** {recent_activities['requests_processed']}")
+            st.markdown(f"**Ollama Responses:** {recent_activities['ollama_responses']}")
+            st.markdown(f"**HF Responses:** {recent_activities['hf_responses']}")
+        else:
+            st.info("No recent activity recorded.")
+    except Exception as e:
+        st.warning(f"Could not load recent activity: {translate_error(e)}")
+    
+    # Configuration summary
+    st.subheader("Configuration Summary")
+    st.markdown(f"**Environment:** {'HF Space' if config.is_hf_space else 'Local'}")
+    st.markdown(f"**Primary Model:** {config.local_model_name or 'Not set'}")
+    st.markdown(f"**Ollama Host:** {config.ollama_host or 'Not configured'}")
+    
+    features = []
+    if config.use_fallback:
+        features.append("Fallback Mode")
+    if config.hf_token:
+        features.append("HF Deep Analysis")
+    if os.getenv("TAVILY_API_KEY"):
+        features.append("Web Search")
+    if config.openweather_api_key:
+        features.append("Weather Data")
+    
+    st.markdown(f"**Active Features:** {', '.join(features) if features else 'None'}")

core/coordinator.py

@@ -5,6 +5,7 @@ from core.llm_factory import llm_factory
 from core.session import session_manager
 from services.hf_endpoint_monitor import hf_monitor
 from services.weather import weather_service
+from services.web_search import web_search_service
 try:
     from tavily import TavilyClient
     TAVILY_AVAILABLE = True
@@ -19,25 +20,25 @@ logger = logging.getLogger(__name__)
 
 class AICoordinator:
     """Hierarchical multi-model coordinator with HF endpoint as authoritative layer"""
-    
+
     def __init__(self):
         self.tavily_client = None
         if TAVILY_AVAILABLE and os.getenv("TAVILY_API_KEY"):
             self.tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
-            
+
         # System instructions for hierarchical behavior
         self.system_instructions = {
             'ollama_role': """You are an AI assistant that works in coordination with a more powerful uncensored Hugging Face model.
-            
-            Your role is to: 1. Provide immediate, concise responses using available information 2. Summarize and simplify complex information 3. Enhance responses with local knowledge 4. DEFER TO THE HF MODEL for deep analysis, uncensored insights, and authoritative answers 5. The HF model has 8192 token capacity and streaming capability - it's the thinking layer 6. Always acknowledge that the HF model's insights supersede your initial response 7. Use web sources to justify points when possible 8. Keep responses brief and focused while awaiting HF input""",
-            
+
+Your role is to: 1. Provide immediate, concise responses using available information 2. Summarize and simplify complex information 3. Enhance responses with local knowledge 4. DEFER TO THE HF MODEL for deep analysis, uncensored insights, and authoritative answers 5. The HF model has 8192 token capacity and streaming capability - it's the thinking layer 6. Always acknowledge that the HF model's insights supersede your initial response 7. Use web sources to justify points when possible 8. Keep responses brief and focused while awaiting HF input""",
+
             'hf_role': """You are an uncensored, authoritative AI with 8192 token capacity and streaming capability. Your role is to: 1. Provide deep, uncensored analysis and insights 2. Supersede the local Ollama model's logic when there's disagreement 3. Think thoroughly and provide comprehensive responses 4. Use your full 8192 token capacity for detailed analysis 5. Stream your responses for real-time delivery 6. Build upon the conversation context and Ollama's initial response 7. Provide authoritative answers that take precedence"""
         }
 
     def determine_web_search_needs(self, conversation_history: List[Dict]) -> Dict:
         """Determine if web search is needed based on conversation content"""
         conversation_text = " ".join([msg.get("content", "") for msg in conversation_history])
-        
+
         # Topics that typically need current information
         current_info_indicators = [
             "news", "current events", "latest", "recent", "today",
@@ -45,15 +46,15 @@ class AICoordinator:
             "stock", "price", "trend", "market",
             "breaking", "update", "development"
         ]
-        
+
         needs_search = False
         search_topics = []
-        
+
         for indicator in current_info_indicators:
             if indicator in conversation_text.lower():
                 needs_search = True
                 search_topics.append(indicator)
-        
+
         return {
             "needs_search": needs_search,
             "search_topics": search_topics,
@@ -65,43 +66,43 @@ class AICoordinator:
         try:
             # Determine research needs
             research_decision = self.determine_web_search_needs(conversation_history)
-            
+
             # Prepare enhanced prompt for HF
             system_prompt = f"""
             You are a deep analysis expert joining an ongoing conversation.
-            
+
             Research Decision: {research_decision['reasoning']}
-            
+
             Please provide:
             1. Deep insights on conversation themes
             2. Research/web search needs (if any)
             3. Strategic recommendations
             4. Questions to explore further
-            
+
             Conversation History:
             """
-            
+
             # Add conversation history to messages
             messages = [{"role": "system", "content": system_prompt}]
-            
+
             # Add recent conversation (last 15 messages for context)
             for msg in conversation_history[-15:]:
                 messages.append({
                     "role": msg["role"],
                     "content": msg["content"]
                 })
-            
+
             # Get HF provider
             from core.llm_factory import llm_factory
             hf_provider = llm_factory.get_provider('huggingface')
-            
+
             if hf_provider:
                 # Generate deep analysis with full 8192 token capacity
                 response = hf_provider.generate("Deep analysis request", messages)
                 return response or "HF Expert analysis completed."
             else:
                 return "❌ HF provider not available."
-        
+
         except Exception as e:
             return f"❌ HF analysis failed: {str(e)}"
 
@@ -111,7 +112,7 @@ class AICoordinator:
         return {
             "hf_available": self._check_hf_availability(),
             "web_search_configured": bool(self.tavily_client),
-            "research_needs_detected": False,  # Will be determined per conversation
+            "research_needs_detected": False,  # Will be determined per conversation,
             "last_hf_analysis": None  # Track last analysis time
         }
 
@@ -123,7 +124,7 @@ class AICoordinator:
             # Get conversation history
             session = session_manager.get_session(user_id)
             conversation_history = session.get("conversation", []).copy()
-            
+
             yield {
                 'type': 'coordination_status',
                 'content': '🚀 Initiating hierarchical AI coordination...',
@@ -132,7 +133,7 @@ class AICoordinator:
                     'user_query_length': len(user_query)
                 }
             }
-            
+
             # Step 1: Gather external data with detailed logging
             yield {
                 'type': 'coordination_status',
@@ -140,7 +141,7 @@ class AICoordinator:
                 'details': {'phase': 'external_data_gathering'}
             }
             external_data = await self._gather_external_data(user_query)
-            
+
             # Log what external data was gathered
             if external_data:
                 data_summary = []
@@ -150,13 +151,13 @@ class AICoordinator:
                     data_summary.append("Weather data: available")
                 if 'current_datetime' in external_data:
                     data_summary.append(f"Time: {external_data['current_datetime']}")
-                
+
                 yield {
                     'type': 'coordination_status',
                     'content': f'📊 External data gathered: {", ".join(data_summary)}',
                     'details': {'external_data_summary': data_summary}
                 }
-            
+
             # Step 2: Get initial Ollama response
             yield {
                 'type': 'coordination_status',
@@ -166,7 +167,7 @@ class AICoordinator:
             ollama_response = await self._get_hierarchical_ollama_response(
                 user_query, conversation_history, external_data
             )
-            
+
             # Send initial response with context info
             yield {
                 'type': 'initial_response',
@@ -176,14 +177,14 @@ class AICoordinator:
                     'external_data_injected': bool(external_data)
                 }
             }
-            
+
             # Step 3: Coordinate with HF endpoint
             yield {
                 'type': 'coordination_status',
                 'content': '🤗 Engaging HF endpoint for deep analysis...',
                 'details': {'phase': 'hf_coordination'}
             }
-            
+
             # Check HF availability
             hf_available = self._check_hf_availability()
             if hf_available:
@@ -193,13 +194,13 @@ class AICoordinator:
                     'ollama_response_length': len(ollama_response),
                     'external_data_items': len(external_data) if external_data else 0
                 }
-                
+
                 yield {
                     'type': 'coordination_status',
                     'content': f'📋 HF context: {len(conversation_history)} conversation turns, Ollama response ({len(ollama_response)} chars)',
                     'details': context_summary
                 }
-                
+
                 # Coordinate with HF
                 async for hf_chunk in self._coordinate_hierarchical_hf_response(
                     user_id, user_query, conversation_history,
@@ -212,14 +213,14 @@ class AICoordinator:
                     'content': 'ℹ️ HF endpoint not available - using Ollama response',
                     'details': {'hf_available': False}
                 }
-            
+
             # Final coordination status
             yield {
                 'type': 'coordination_status',
                 'content': '✅ Hierarchical coordination complete',
                 'details': {'status': 'complete'}
             }
-        
+
         except Exception as e:
             logger.error(f"Hierarchical coordination failed: {e}")
             yield {
@@ -235,29 +236,29 @@ class AICoordinator:
         try:
             # Check and warm up HF endpoint if needed
             hf_status = hf_monitor.check_endpoint_status()
-            
+
             if not hf_status['available']:
                 yield {'type': 'coordination_status', 'content': '⚡ Initializing HF endpoint (2-4 minutes)...'}
                 warmup_success = hf_monitor.handle_scale_to_zero()
                 if not warmup_success:
                     yield {'type': 'coordination_status', 'content': '❌ HF endpoint initialization failed'}
                     return
-            
+
             # Get HF provider
             hf_provider = llm_factory.get_provider('huggingface')
             if not hf_provider:
                 yield {'type': 'coordination_status', 'content': '❌ HF provider not available'}
                 return
-            
+
             # Prepare enhanced conversation for HF with hierarchical context
             enhanced_history = history.copy()
-            
+
             # Add system instructions for HF
             enhanced_history.insert(0, {
                 "role": "system",
                 "content": self.system_instructions['hf_role']
             })
-            
+
             # Add context about the coordination
             enhanced_history.append({
                 "role": "system",
@@ -265,21 +266,21 @@ class AICoordinator:
                 User Query: '{query}'
                 Ollama's Initial Response: '{ollama_response}'
                 External Data Available: {json.dumps(external_data, indent=2) if external_data else 'None'}
-                
+
                 Please provide your deep, uncensored analysis that supersedes the local model's response.
                 Use your full 8192 token capacity for comprehensive thinking.
                 Stream your response for real-time delivery."""
             })
-            
+
             # Add the user's latest query
             enhanced_history.append({"role": "user", "content": query})
-            
+
             # Stream HF response with full 8192 token capacity
             yield {'type': 'coordination_status', 'content': '🧠 HF endpoint thinking...'}
-            
+
             # Use streaming for real-time delivery
             hf_response_stream = hf_provider.stream_generate(query, enhanced_history)
-            
+
             if hf_response_stream:
                 # Stream the response chunks
                 full_hf_response = ""
@@ -287,7 +288,7 @@ class AICoordinator:
                     if chunk:
                         full_hf_response += chunk
                         yield {'type': 'hf_thinking', 'content': chunk}
-                
+
                 # Final HF response
                 yield {'type': 'final_response', 'content': full_hf_response}
                 yield {'type': 'coordination_status', 'content': '🎯 HF analysis complete and authoritative'}
@@ -305,16 +306,16 @@ class AICoordinator:
             ollama_provider = llm_factory.get_provider('ollama')
             if not ollama_provider:
                 raise Exception("Ollama provider not available")
-            
+
             # Prepare conversation with hierarchical context
             enhanced_history = history.copy()
-            
+
             # Add system instruction for Ollama's role
             enhanced_history.insert(0, {
                 "role": "system",
                 "content": self.system_instructions['ollama_role']
             })
-            
+
             # Add external data context if available
             if external_data:
                 context_parts = []
@@ -325,26 +326,26 @@ class AICoordinator:
                     context_parts.append(f"Current weather: {weather.get('temperature', 'N/A')}°C in {weather.get('city', 'Unknown')}")
                 if 'current_datetime' in external_data:
                     context_parts.append(f"Current time: {external_data['current_datetime']}")
-                
+
                 if context_parts:
                     context_message = {
                         "role": "system",
                         "content": "Context: " + " | ".join(context_parts)
                     }
                     enhanced_history.insert(1, context_message)  # Insert after role instruction
-            
+
             # Add the user's query
             enhanced_history.append({"role": "user", "content": query})
-            
+
             # Generate response with awareness of HF's superior capabilities
             response = ollama_provider.generate(query, enhanced_history)
-            
+
             # Add acknowledgment of HF's authority
             if response:
                 return f"{response}\n\n*Note: A more comprehensive analysis from the uncensored HF model is being prepared...*"
             else:
                 return "I'm processing your request... A deeper analysis is being prepared by the authoritative model."
-        
+
         except Exception as e:
             logger.error(f"Hierarchical Ollama response failed: {e}")
             return "I'm thinking about your question... Preparing a comprehensive response."
@@ -360,24 +361,18 @@ class AICoordinator:
     async def _gather_external_data(self, query: str) -> Dict:
         """Gather external data from various sources"""
         data = {}
-        
+
         # Tavily/DuckDuckGo search with justification focus
-        if self.tavily_client:
+        if self.tavily_client or web_search_service.client:
             try:
-                search_result = self.tavily_client.search(
-                    f"current information about {query}",
-                    max_results=5,  # More results for better justification
-                    include_answer=True,
-                    include_raw_content=True  # For deeper analysis
-                )
-                data['search_results'] = search_result.get('results', [])
-                if search_result.get('answer'):
-                    data['search_answer'] = search_result['answer']
-                # Store raw content for HF to analyze
-                data['raw_sources'] = [result.get('raw_content', '')[:1000] for result in search_result.get('results', [])[:3]]
+                search_results = web_search_service.search(f"current information about {query}")
+                if search_results:
+                    data['search_results'] = search_results
+                    # Optionally extract answer summary
+                    # data['search_answer'] = ...
             except Exception as e:
                 logger.warning(f"Tavily search failed: {e}")
-        
+
         # Weather data
         weather_keywords = ['weather', 'temperature', 'forecast', 'climate', 'rain', 'sunny']
         if any(keyword in query.lower() for keyword in weather_keywords):
@@ -388,10 +383,10 @@ class AICoordinator:
                     data['weather'] = weather
             except Exception as e:
                 logger.warning(f"Weather data failed: {e}")
-        
+
         # Current date/time
         data['current_datetime'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
+
         return data
 
     def _extract_location(self, query: str) -> Optional[str]:

requirements.txt

@@ -10,3 +10,4 @@ docker==6.1.3
 pygame==2.5.2
 pydantic==1.10.7
 typing-extensions>=4.5.0
+semanticscholar>=0.1.8

services/research/papers.py

@@ -0,0 +1,32 @@
+from semanticscholar import SemanticScholar
+import logging
+
+logger = logging.getLogger(__name__)
+
+scholar = SemanticScholar(timeout=10)
+
+def find_papers(query: str, limit: int = 5):
+    """
+    Search academic papers via Semantic Scholar API.
+    Returns simplified paper metadata.
+    """
+    try:
+        results = scholar.search_paper(query, limit=limit)
+        papers = []
+        for paper in results:
+            papers.append({
+                'title': paper.title,
+                'authors': [author.name for author in paper.authors],
+                'abstract': paper.abstract,
+                'year': paper.year,
+                'url': paper.url,
+                'citation_count': getattr(paper, 'citationCount', 0),
+                'venue': getattr(paper, 'venue', '')
+            })
+        return papers
+    except Exception as e:
+        logger.error(f"Paper search failed: {e}")
+        return []
+
+# Example usage:
+# papers = find_papers("vitamin D immune system")

services/web_search.py

@@ -0,0 +1,39 @@
+import os
+from typing import Optional, Dict, List
+try:
+    from tavily import TavilyClient
+    TAVILY_AVAILABLE = True
+except ImportError:
+    TavilyClient = None
+    TAVILY_AVAILABLE = False
+
+class WebSearchService:
+    def __init__(self):
+        self.client = None
+        api_key = os.getenv("TAVILY_API_KEY")
+        if api_key and TAVILY_AVAILABLE:
+            self.client = TavilyClient(api_key=api_key)
+
+    def search(self, query: str, max_results: int = 5) -> Optional[List[Dict]]:
+        """
+        Perform a web search using Tavily.
+        Returns list of results with title, url, content.
+        """
+        if not self.client:
+            print("⚠️ Tavily API key not configured.")
+            return []
+
+        try:
+            response = self.client.search(
+                query=query,
+                max_results=max_results,
+                include_answer=True,
+                include_raw_content=False
+            )
+            return response.get("results", [])
+        except Exception as e:
+            print(f"❌ Web search failed: {e}")
+            return []
+
+# Global instance
+web_search_service = WebSearchService()