Update app.py imports and send button logic, enhance config detection for HF Spaces, improve HF token validation

app.py

@@ -1,390 +1,120 @@
-# Force redeploy trigger - version 2.3
 import streamlit as st
-from utils.config import config
-import requests
-import json
+import time
 import os
-from core.memory import load_user_state, check_redis_health
-
-# Set page config FIRST (before any other Streamlit commands)
-st.set_page_config(page_title="AI Life Coach", page_icon="🧘", layout="centered")
-
-# ROBUST SESSION STATE INITIALIZATION
-# This must happen before ANY widget creation
-def init_session_state():
-    """Initialize all session state variables with proper defaults"""
-    defaults = {
-        'ngrok_url': config.ollama_host,
-        'model_status': "checking",
-        'available_models': [],
-        'selected_model': config.local_model_name,
-        'selected_model_index': 0,
-        'user_message_input': "",
-        'user_selector': "Rob"  # Add missing default
-    }
-    
-    for key, default_value in defaults.items():
-        if key not in st.session_state:
-            st.session_state[key] = default_value
-
-# CALL THIS FIRST
-init_session_state()
-
-# Sidebar for user selection
-st.sidebar.title("🧘 AI Life Coach")
-user = st.sidebar.selectbox("Select User", ["Rob", "Sarah"], key="user_selector")
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent))
 
-# Ngrok URL input in sidebar - UPDATED VERSION
-st.sidebar.markdown("---")
-st.sidebar.subheader("Ollama Connection")
-ngrok_input = st.sidebar.text_input(
-    "Ngrok URL", 
-    value=st.session_state.ngrok_url, 
-    key="ngrok_url_input"  # Explicit key
-)
-
-if st.sidebar.button("Update Ngrok URL", key="update_ngrok_button"):
-    # Explicit key
-    st.session_state.ngrok_url = ngrok_input
-    st.session_state.model_status = "checking"
-    st.session_state.available_models = []
-    st.session_state.selected_model_index = 0  # Reset model index
-    st.sidebar.success("Ngrok URL updated!")
-    st.experimental_rerun()
-
-# Headers to skip ngrok browser warning
-NGROK_HEADERS = {
-    "ngrok-skip-browser-warning": "true",
-    "User-Agent": "AI-Life-Coach-App"
-}
-
-# Fetch available models
-def fetch_available_models(ngrok_url):
-    try:
-        response = requests.get(
-            f"{ngrok_url}/api/tags", 
-            headers=NGROK_HEADERS, 
-            timeout=5
-        )
-        if response.status_code == 200:
-            models_data = response.json().get("models", [])
-            return [m.get("name") for m in models_data]
-    except Exception:
-        pass
-    return []
-
-# Update available models if st.session_state.ngrok_url and st.session_state.model_status != "unreachable":
-model_names = fetch_available_models(st.session_state.ngrok_url)
-if model_names:
-    st.session_state.available_models = model_names
-    # If current selected model not in list, select the first one
-    if st.session_state.selected_model not in model_names:
-        st.session_state.selected_model = model_names[0]
-        st.session_state.selected_model_index = 0
+from utils.config import config
+from core.llm import send_to_ollama, send_to_hf
+from core.memory import get_conversation_history
 
-# Model selector dropdown - REPLACED ENTIRE SECTION
-st.sidebar.markdown("---")
-st.sidebar.subheader("Model Selection")
+st.set_page_config(page_title="AI Life Coach", page_icon="🧠", layout="wide")
 
-# Initialize selected_model_index in session state if not present
-if 'selected_model_index' not in st.session_state:
-    st.session_state.selected_model_index = 0
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
 
-if st.session_state.available_models:
-    # Ensure selected_model_index is within bounds
-    if st.session_state.selected_model_index >= len(st.session_state.available_models):
-        st.session_state.selected_model_index = 0
+# Sidebar
+with st.sidebar:
+    st.title("AI Life Coach")
+    st.markdown("Your personal AI-powered life development assistant")
     
-    # Find index of currently selected model
-    if st.session_state.selected_model in st.session_state.available_models:
-        st.session_state.selected_model_index = st.session_state.available_models.index(st.session_state.selected_model)
-    else:
-        # If current model not available, select first one
-        st.session_state.selected_model_index = 0
-        if st.session_state.available_models:
-            st.session_state.selected_model = st.session_state.available_models[0]
+    # Model selection
+    model_options = {
+        "Mistral 7B (Local)": "mistral:latest",
+        "Llama 2 7B (Local)": "llama2:latest",
+        "OpenChat 3.5 (Local)": "openchat:latest"
+    }
     
-    # Use index-based selection to avoid widget key issues
-    selected_model = st.sidebar.selectbox(
+    selected_model_name = st.selectbox(
         "Select Model",
-        st.session_state.available_models,
-        index=st.session_state.selected_model_index,
-        key="model_selector"  # Explicit key to prevent conflicts
+        options=list(model_options.keys()),
+        index=0
     )
-    st.session_state.selected_model = selected_model
-else:
-    st.sidebar.warning("No models available - check Ollama connection")
-    model_input = st.sidebar.text_input(
-        "Or enter model name",
-        value=st.session_state.selected_model,
-        key="manual_model_input"  # Explicit key
+    
+    st.session_state.selected_model = model_options[selected_model_name]
+    
+    # Ollama URL input
+    st.session_state.ngrok_url = st.text_input(
+        "Ollama Server URL",
+        value=st.session_state.get("ngrok_url", "http://localhost:11434"),
+        help="Enter the URL to your Ollama server"
     )
-    st.session_state.selected_model = model_input
-
-st.sidebar.markdown("---")
-
-# Get environment info
-BASE_URL = os.environ.get("SPACE_ID", "")
-IS_HF_SPACE = bool(BASE_URL)
-
-# Fetch Ollama status with enhanced error handling
-def get_ollama_status(ngrok_url):
-    try:
-        response = requests.get(
-            f"{ngrok_url}/api/tags",
-            headers=NGROK_HEADERS,
-            timeout=15  # Increased timeout
-        )
-        if response.status_code == 200:
-            models = response.json().get("models", [])
-            model_names = [m.get("name") for m in models]
-            st.session_state.available_models = model_names
-            if models:
-                selected_model_available = st.session_state.selected_model in model_names
-                return {
-                    "running": True,
-                    "model_loaded": st.session_state.selected_model if selected_model_available else model_names[0],
-                    "remote_host": ngrok_url,
-                    "available_models": model_names,
-                    "selected_model_available": selected_model_available
-                }
-            else:
-                st.session_state.model_status = "no_models"
-                return {
-                    "running": True,  # Server is running but no models
-                    "model_loaded": None,
-                    "remote_host": ngrok_url,
-                    "message": "Connected to Ollama but no models found"
-                }
-        elif response.status_code == 404:
-            # Server might be running but endpoint not available
-            response2 = requests.get(f"{ngrok_url}", headers=NGROK_HEADERS, timeout=10)
-            if response2.status_code == 200:
-                st.session_state.model_status = "checking"
-                return {
-                    "running": True,
-                    "model_loaded": "unknown",
-                    "remote_host": ngrok_url,
-                    "message": "Server running, endpoint check inconclusive"
-                }
-            else:
-                st.session_state.model_status = "unreachable"
-                return {
-                    "running": False,
-                    "model_loaded": None,
-                    "error": f"HTTP {response.status_code}",
-                    "remote_host": ngrok_url
-                }
-        else:
-            st.session_state.model_status = "unreachable"
-            return {
-                "running": False,
-                "model_loaded": None,
-                "error": f"HTTP {response.status_code}",
-                "remote_host": ngrok_url
-            }
-    except requests.exceptions.Timeout:
-        st.session_state.model_status = "unreachable"
-        return {
-            "running": False,
-            "model_loaded": None,
-            "error": "Timeout - server not responding",
-            "remote_host": ngrok_url
-        }
-    except Exception as e:
-        st.session_state.model_status = "unreachable"
-        return {
-            "running": False,
-            "model_loaded": None,
-            "error": str(e),
-            "remote_host": ngrok_url
-        }
-
-# Load conversation history
-def get_conversation_history(user_id):
-    try:
-        user_state = load_user_state(user_id)
-        if user_state and "conversation" in user_state:
-            return json.loads(user_state["conversation"])
-    except Exception as e:
-        st.warning(f"Could not load conversation history: {e}")
-    return []
-
-# Get Ollama status with null safety
-ollama_status = get_ollama_status(st.session_state.ngrok_url)
-
-# Add null safety check
-if ollama_status is None:
-    ollama_status = {
-        "running": False,
-        "model_loaded": None,
-        "error": "Failed to get Ollama status",
-        "remote_host": st.session_state.ngrok_url
-    }
-
-# Update model status with better logic
-if ollama_status and ollama_status.get("running", False):
-    if ollama_status.get("available_models") and len(ollama_status.get("available_models", [])) > 0:
-        st.session_state.model_status = "ready"
-    elif ollama_status.get("model_loaded") == "unknown":
-        st.session_state.model_status = "ready"  # Assume ready if server responds
-    else:
-        st.session_state.model_status = "no_models"
-else:
-    st.session_state.model_status = "unreachable"
-
-# Ensure ollama_status is a dict even if None
-ollama_status = ollama_status or {}
-
-# Determine if we should use fallback
-use_fallback = not ollama_status.get("running", False) or config.use_fallback
-
-# Display Ollama status - Enhanced section with Hugging Face scaling behavior info
-if use_fallback:
-    st.sidebar.warning("🌐 Using Hugging Face fallback (Ollama not available)")
-    # Add special note for Hugging Face scaling behavior
-    if config.hf_api_url and "endpoints.huggingface.cloud" in config.hf_api_url:
-        st.sidebar.info("ℹ️ HF Endpoint may be initializing (up to 4 min)")
-    if "error" in ollama_status:
-        st.sidebar.caption(f"Error: {ollama_status['error'][:50]}...")
-else:
-    model_status_msg = ollama_status.get('model_loaded', 'Unknown')
-    if ollama_status.get('selected_model_available', True):
-        st.sidebar.success(f"🧠 Ollama Model: {model_status_msg}")
-    else:
-        st.sidebar.warning(f"🧠 Ollama Model: {model_status_msg} (selected model not available)")
-    st.sidebar.info(f"Connected to: {ollama_status['remote_host']}")
-
-# Status indicators
-model_status_container = st.sidebar.empty()
-if st.session_state.model_status == "ready":
-    model_status_container.success("✅ Model Ready")
-elif st.session_state.model_status == "checking":
-    model_status_container.info("🔍 Checking model...")
-elif st.session_state.model_status == "no_models":
-    model_status_container.warning("⚠️ No models found")
-else:
-    model_status_container.error("❌ Ollama unreachable")
-
-redis_status_container = st.sidebar.empty()
-if check_redis_health():
-    redis_status_container.success("✅ Redis Connected")
-else:
-    redis_status_container.warning("⚠️ Redis Not Available")
+    
+    # Conversation history
+    st.subheader("Conversation History")
+    if st.button("Clear History"):
+        st.session_state.messages = []
+        st.success("History cleared!")
 
 # Main chat interface
-st.title("🧘 AI Life Coach")
-st.markdown("Talk to your personal development assistant.")
-
-# Show detailed status with st.expander("🔍 Connection Status"):
-st.write("Ollama Status:", ollama_status)
-st.write("Model Status:", st.session_state.model_status)
-st.write("Selected Model:", st.session_state.selected_model)
-st.write("Available Models:", st.session_state.available_models)
-st.write("Environment Info:")
-st.write("- Is HF Space:", IS_HF_SPACE)
-st.write("- Base URL:", BASE_URL or "Not in HF Space")
-st.write("- Current Ngrok URL:", st.session_state.ngrok_url)
-st.write("- Using Fallback:", use_fallback)
-st.write("- Redis Health:", check_redis_health())
-
-# Function to send message to Ollama
-def send_to_ollama(user_input, conversation_history, ngrok_url, model_name):
-    try:
-        # Use the correct chat endpoint with proper payload
-        payload = {
-            "model": model_name,
-            "messages": conversation_history,
-            "stream": False,
-            "options": {
-                "temperature": 0.7,
-                "top_p": 0.9
-            }
-        }
-        response = requests.post(
-            f"{ngrok_url}/api/chat", 
-            json=payload, 
-            headers=NGROK_HEADERS, 
-            timeout=60
-        )
-        if response.status_code == 200:
-            response_data = response.json()
-            return response_data.get("message", {}).get("content", "")
-        else:
-            st.error(f"Ollama API error: {response.status_code}")
-            st.error(response.text[:200])
-            return None
-    except Exception as e:
-        st.error(f"Connection error: {e}")
-        return None
-
-# Function to send message to Hugging Face (fallback)
-def send_to_hf(user_input, conversation_history):
-    try:
-        from core.llm import LLMClient
-        llm_client = LLMClient(provider="huggingface")
-        # Format for HF
-        prompt = "You are a helpful life coach. "
-        for msg in conversation_history:
-            if msg["role"] == "user":
-                prompt += f"Human: {msg['content']} "
-            elif msg["role"] == "assistant":
-                prompt += f"Assistant: {msg['content']} "
-        prompt += "Assistant:"
-        response = llm_client.generate(prompt, max_tokens=500, stream=False)
-        return response
-    except Exception as e:
-        st.error(f"Hugging Face API error: {e}")
-        return None
-
-# Display conversation history
-conversation = get_conversation_history(user)
-for msg in conversation:
-    role = msg["role"].capitalize()
-    content = msg["content"]
-    st.markdown(f"{role}: {content}")
-
-# Chat input - REPLACED SECTION
-user_input = st.text_input(
-    "Your message...", 
-    key="user_message_input",  # Explicit key
-    placeholder="Type your message here...",
-    value=st.session_state.user_message_input
-)
+st.title("🧠 AI Life Coach")
+st.markdown("Ask me anything about personal development, goal setting, or life advice!")
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Chat input and send button
+col1, col2 = st.columns([4, 1])
+with col1:
+    user_input = st.text_input(
+        "Your message...",
+        key="user_message_input",
+        placeholder="Type your message here...",
+        label_visibility="collapsed"
+    )
 
-# Use a separate key for the button to avoid conflicts
-send_button = st.button("Send", key="send_message_button")
+with col2:
+    send_button = st.button("Send", key="send_message_button", use_container_width=True)
 
-if send_button:
-    if user_input.strip() == "":
-        st.warning("Please enter a message.")
-    else:
-        # Display user message
-        st.markdown(f"You: {user_input}")
-        
-        # Prepare conversation history
-        conversation_history = [{"role": msg["role"], "content": msg["content"]} for msg in conversation[-5:]]
-        conversation_history.append({"role": "user", "content": user_input})
-        
-        # Send to appropriate backend
+if send_button and user_input.strip():
+    # Display user message
+    with st.chat_message("user"):
+        st.markdown(user_input)
+    
+    # Add user message to history
+    st.session_state.messages.append({"role": "user", "content": user_input})
+    
+    # Get conversation history
+    conversation = get_conversation_history("default_user")
+    conversation_history = conversation[-5:]  # Last 5 messages
+    conversation_history.append({"role": "user", "content": user_input})
+    
+    # Send to backend
+    with st.chat_message("assistant"):
         with st.spinner("AI Coach is thinking..."):
-            if use_fallback:
-                ai_response = send_to_hf(user_input, conversation_history)
-                backend_used = "Hugging Face"
-            else:
+            ai_response = None
+            backend_used = ""
+            
+            # Try Ollama first if not falling back
+            if not config.use_fallback:
                 ai_response = send_to_ollama(
-                    user_input, 
-                    conversation_history, 
-                    st.session_state.ngrok_url, 
+                    user_input,
+                    conversation_history,
+                    st.session_state.ngrok_url,
                     st.session_state.selected_model
                 )
                 backend_used = "Ollama"
             
+            # Fallback to Hugging Face
+            if not ai_response and config.hf_token:
+                ai_response = send_to_hf(user_input, conversation_history)
+                backend_used = "Hugging Face"
+            
             if ai_response:
-                st.markdown(f"AI Coach ({backend_used}): {ai_response}")
+                st.markdown(f"{ai_response}")
+                
+                # Update conversation history (stub – actual save will come later)
+                conversation.append({"role": "user", "content": user_input})
+                conversation.append({"role": "assistant", "content": ai_response})
+                
+                # Add assistant response to history
+                st.session_state.messages.append({"role": "assistant", "content": ai_response})
             else:
-                st.error(f"Failed to get response from {backend_used}.")
-        
-        # Clear input after sending (this helps prevent duplicate sends)
-        st.session_state.user_message_input = ""
-        st.experimental_rerun()
+                st.error("Failed to get response from both providers.")
+    
+    # Clear input by forcing rerun
+    st.experimental_rerun()

core/llm.py

@@ -1,10 +1,8 @@
 import openai
+import requests
 import time
-from typing import Dict, Any, List, Optional
-from core.config import config
-import logging
-
-logger = logging.getLogger(__name__)
+from typing import List, Dict, Optional
+from utils.config import config
 
 class LLMProvider:
     def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
@@ -12,91 +10,59 @@ class LLMProvider:
         self.timeout = timeout
         self.retries = retries
 
-    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
-        raise NotImplementedError
-
-class HuggingFaceProvider(LLMProvider):
-    def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
-        super().__init__(model_name, timeout, retries)
-        # Remove proxies parameter that causes the error
-        self.client = openai.OpenAI(
-            base_url=config.hf_api_url,
-            api_key=config.hf_token
-            # Removed: proxies parameter
-        )
-
-    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
+class OllamaProvider(LLMProvider):
+    def generate_response(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        url = f"{config.ollama_host}/api/chat"
+        messages = conversation_history
+        
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            "stream": False
+        }
+        
         for attempt in range(self.retries):
             try:
-                response = self.client.chat.completions.create(
-                    model=self.model_name,
-                    messages=messages,
-                    timeout=self.timeout,
-                    **kwargs
-                )
-                return response.choices[0].message.content
+                response = requests.post(url, json=payload, timeout=self.timeout)
+                response.raise_for_status()
+                return response.json()["message"]["content"]
             except Exception as e:
-                logger.error(f"HuggingFace API error (attempt {attempt + 1}/{self.retries}): {e}")
                 if attempt == self.retries - 1:
-                    raise
+                    print(f"Error after {self.retries} attempts: {e}")
+                    return None
                 time.sleep(2 ** attempt)  # Exponential backoff
-        return ""
+        return None
 
-class OllamaProvider(LLMProvider):
+class HuggingFaceProvider(LLMProvider):
     def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
         super().__init__(model_name, timeout, retries)
+        if not config.hf_token:
+            raise ValueError("HF_TOKEN not set - required for Hugging Face provider")
+        
         self.client = openai.OpenAI(
-            base_url=config.ollama_host + "/v1",
-            api_key="ollama"  # Ollama doesn't require an API key
+            base_url=config.hf_api_url,
+            api_key=config.hf_token
         )
+    
+    def generate_response(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=conversation_history,
+                max_tokens=500,
+                temperature=0.7
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"Hugging Face API error: {e}")
+            return None
 
-    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
-        for attempt in range(self.retries):
-            try:
-                response = self.client.chat.completions.create(
-                    model=self.model_name,
-                    messages=messages,
-                    timeout=self.timeout,
-                    **kwargs
-                )
-                return response.choices[0].message.content
-            except Exception as e:
-                logger.error(f"Ollama API error (attempt {attempt + 1}/{self.retries}): {e}")
-                if attempt == self.retries - 1:
-                    raise
-                time.sleep(2 ** attempt)  # Exponential backoff
-        return ""
-
-class OpenAIProvider(LLMProvider):
-    def __init__(self, model_name: str, timeout: int = 30, retries: int = 3):
-        super().__init__(model_name, timeout, retries)
-        self.client = openai.OpenAI(api_key=config.openai_api_key)
-
-    def generate_response(self, messages: List[Dict[str, str]], **kwargs) -> str:
-        for attempt in range(self.retries):
-            try:
-                response = self.client.chat.completions.create(
-                    model=self.model_name,
-                    messages=messages,
-                    timeout=self.timeout,
-                    **kwargs
-                )
-                return response.choices[0].message.content
-            except Exception as e:
-                logger.error(f"OpenAI API error (attempt {attempt + 1}/{self.retries}): {e}")
-                if attempt == self.retries - 1:
-                    raise
-                time.sleep(2 ** attempt)  # Exponential backoff
-        return ""
+def send_to_ollama(prompt: str, conversation_history: List[Dict], ollama_url: str, model: str) -> Optional[str]:
+    config.ollama_host = ollama_url
+    provider = OllamaProvider(model)
+    return provider.generate_response(prompt, conversation_history)
 
-def get_llm_provider(provider_name: str, model_name: str) -> LLMProvider:
-    providers = {
-        "huggingface": HuggingFaceProvider,
-        "ollama": OllamaProvider,
-        "openai": OpenAIProvider
-    }
-    
-    if provider_name not in providers:
-        raise ValueError(f"Unsupported provider: {provider_name}")
-    
-    return providers[provider_name](model_name)
+def send_to_hf(prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+    # Using a common model that works well for coaching
+    provider = HuggingFaceProvider("meta-llama/Llama-2-7b-chat-hf")
+    return provider.generate_response(prompt, conversation_history)

utils/config.py

@@ -4,14 +4,15 @@ from dotenv import load_dotenv
 class Config:
     def __init__(self):
         load_dotenv()
+        
+        # Detect if running on HF Spaces
+        self.is_hf_space = bool(os.getenv("SPACE_ID"))
+        
         self.hf_token = os.getenv("HF_TOKEN")
         self.hf_api_url = os.getenv("HF_API_ENDPOINT_URL", "https://api-inference.huggingface.co/v1/")
-        self.use_fallback = os.getenv("USE_FALLBACK", "false").lower() == "true"
-        self.tavily_api_key = os.getenv("TAVILY_API_KEY")
-        self.openweather_api_key = os.getenv("OPENWEATHER_API_KEY")
-        self.nasa_api_key = os.getenv("NASA_API_KEY")
+        self.use_fallback = os.getenv("USE_FALLBACK", "true").lower() == "true"
         
-        # Redis configuration with proper defaults for local development
+        # Redis configuration (optional for HF)
         self.redis_host = os.getenv("REDIS_HOST", "localhost")
         self.redis_port = int(os.getenv("REDIS_PORT", "6379"))
         self.redis_username = os.getenv("REDIS_USERNAME", "")
@@ -20,8 +21,8 @@ class Config:
         self.redis_retry_delay = int(os.getenv("REDIS_RETRY_DELAY", "1"))
         
         # Local model configuration
-        self.local_model_name = os.getenv("LOCAL_MODEL_NAME", "mistral")
-        # Update to use the working ngrok URL from your logs
-        self.ollama_host = os.getenv("OLLAMA_HOST", "https://f943b91f0a0c.ngrok-free.app")
+        self.local_model_name = os.getenv("LOCAL_MODEL_NAME", "mistral:latest")
+        self.ollama_host = os.getenv("OLLAMA_HOST", "")
 
+# Global config instance
 config = Config()