Herarchy

app.py

@@ -2,6 +2,7 @@ import streamlit as st
 import time
 import os
 import sys
+import json
 from datetime import datetime
 from pathlib import Path
 sys.path.append(str(Path(__file__).parent))
@@ -27,6 +28,8 @@ if "is_processing" not in st.session_state:
     st.session_state.is_processing = False
 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 "manual_hf_requested" not in st.session_state:
+    st.session_state.manual_hf_requested = False
 
 # Sidebar
 with st.sidebar:
@@ -130,10 +133,99 @@ st.markdown("Ask me anything about personal development, goal setting, or life a
 # Display messages
 for message in st.session_state.messages:
     with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+        # 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 Button
+if st.session_state.messages and len(st.session_state.messages) > 0:
+    st.divider()
+    st.subheader("🎯 Deep Analysis")
+    
+    col1, col2 = st.columns([1, 3])
+    with col1:
+        if st.button("🧠 Bring HF Expert Into Conversation",
+                     help="Send entire conversation to HF endpoint for deep analysis",
+                     key="manual_hf_button",
+                     disabled=st.session_state.is_processing):
+            # Trigger HF analysis
+            st.session_state.manual_hf_requested = True
+    
+    # Show HF analysis if requested
+    if st.session_state.get("manual_hf_requested", False):
+        with st.spinner("🧠 HF Expert joining conversation..."):
+            try:
+                # Get conversation history
+                user_session = session_manager.get_session("default_user")
+                conversation_history = user_session.get("conversation", [])
+                
+                # Create HF analysis request
+                analysis_prompt = f"""
+                You are joining an ongoing conversation as a deep analysis expert.
+                Please analyze the entire conversation history and provide:
+                1. Key themes and patterns
+                2. Deeper insights on topics discussed
+                3. Suggestions for next steps
+                4. Any research needs (specify if web search needed)
+                
+                Conversation History:
+                """
+                
+                # Get HF provider
+                from core.llm_factory import llm_factory
+                hf_provider = llm_factory.get_provider('huggingface')
+                
+                if hf_provider:
+                    # Prepare messages for HF
+                    hf_messages = [
+                        {"role": "system", "content": analysis_prompt}
+                    ]
+                    
+                    # Add conversation history
+                    for msg in conversation_history[-10:]:  # Last 10 messages for context
+                        hf_messages.append({
+                            "role": msg["role"],
+                            "content": msg["content"]
+                        })
+                    
+                    # Generate deep analysis
+                    hf_response = hf_provider.generate(
+                        analysis_prompt,
+                        hf_messages
+                    )
+                    
+                    if hf_response:
+                        # Display HF expert response
+                        with st.chat_message("assistant"):
+                            st.markdown("**🤖 HF Expert Analysis:**")
+                            st.markdown(hf_response)
+                        
+                        # Add to message history
+                        st.session_state.messages.append({
+                            "role": "assistant",
+                            "content": hf_response,
+                            "timestamp": datetime.now().strftime("%H:%M:%S"),
+                            "source": "hf_expert"
+                        })
+                        
+                        st.session_state.manual_hf_requested = False
+                    else:
+                        st.error("❌ HF analysis failed - no response")
+                else:
+                    st.error("❌ HF provider not available")
+            
+            except Exception as e:
+                st.error(f"❌ HF analysis failed: {str(e)}")
+            finally:
+                st.session_state.manual_hf_requested = False
+                time.sleep(0.5)
+                st.experimental_rerun()
+
 # Chat input - FIXED VERSION
 user_input = st.chat_input("Type your message here...", disabled=st.session_state.is_processing)
 

core/coordinator.py

@@ -50,6 +50,85 @@ Your role is to:
 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"""
+        needs_search = False
+        search_topics = []
+        
+        # Extract key topics from conversation
+        conversation_text = " ".join([msg.get("content", "") for msg in conversation_history])
+        
+        # Topics that typically need current information
+        current_info_topics = [
+            "news", "current events", "latest", "recent", "today",
+            "weather", "stock", "price", "trend", "update",
+            "breaking", "new development", "recent study"
+        ]
+        
+        # Check if conversation contains time-sensitive topics
+        for topic in current_info_topics:
+            if topic in conversation_text.lower():
+                needs_search = True
+                search_topics.append(topic)
+        
+        return {
+            "needs_search": needs_search,
+            "search_topics": search_topics,
+            "reasoning": f"Found topics requiring current info: {', '.join(search_topics)}" if search_topics else "No current info needed"
+        }
+
+    async def manual_hf_analysis(self, user_id: str, conversation_history: List[Dict]) -> str:
+        """Perform manual HF analysis with web search integration"""
+        try:
+            # Determine if web search is needed
+            search_decision = self.determine_web_search_needs(conversation_history)
+            
+            # Prepare enhanced prompt for HF
+            prompt = f"""
+            You are a deep analysis expert joining an ongoing conversation.
+            Conversation participants want your expert insights.
+            
+            Web Search Decision: {search_decision['reasoning']}
+            
+            Please provide:
+            1. Deep insights on the conversation themes
+            2. Any research needs (specify if web search needed)
+            3. Strategic recommendations
+            4. Questions to explore further
+            
+            Conversation History:
+            """
+            
+            # Add web search if needed
+            if search_decision["needs_search"]:
+                prompt += "\n\n[Note: Web search will be performed for current information]"
+            
+            # Get HF provider
+            from core.llm_factory import llm_factory
+            hf_provider = llm_factory.get_provider('huggingface')
+            
+            if hf_provider:
+                # Prepare messages for HF with full context
+                hf_messages = [
+                    {"role": "system", "content": prompt}
+                ]
+                
+                # Add conversation history
+                for msg in conversation_history[-15:]:  # Last 15 messages for rich context
+                    hf_messages.append({
+                        "role": msg["role"],
+                        "content": msg["content"]
+                    })
+                
+                # Generate response with full 8192 token capacity
+                response = hf_provider.generate(prompt, hf_messages)
+                return response
+            else:
+                return "❌ HF provider not available for deep analysis"
+                
+        except Exception as e:
+            return f"❌ HF analysis failed: {str(e)}"
+
     async def coordinate_hierarchical_conversation(self, user_id: str, user_query: str) -> AsyncGenerator[Dict, None]:
         """
         Enhanced coordination with detailed tracking and feedback

core/session.py

@@ -182,6 +182,30 @@ class SessionManager:
             logger.error(f"Error updating hierarchical coordination for user {user_id}: {e}")
             return False
 
+    def add_hf_expert_to_conversation(self, user_id: str, hf_analysis: str) -> bool:
+        """Add HF expert participation to conversation history"""
+        try:
+            session = self.get_session(user_id)
+            
+            # Add HF expert entry to conversation
+            hf_entry = {
+                "role": "assistant",
+                "content": hf_analysis,
+                "timestamp": datetime.now().isoformat(),
+                "type": "hf_expert_analysis"
+            }
+            
+            conversation = session.get("conversation", [])
+            conversation.append(hf_entry)
+            session["conversation"] = conversation
+            
+            # Update session
+            return self.update_session(user_id, session)
+        
+        except Exception as e:
+            logger.error(f"Error adding HF expert to conversation: {e}")
+            return False
+
     def get_hierarchical_stats(self, user_id: str) -> Dict:
         """Get hierarchical coordination statistics"""
         try: