Initial Commit

Dockerfile

@@ -0,0 +1,27 @@
+# Use Python 3.10 slim image as base
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+      ffmpeg \
+      git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /code
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all application code
+COPY . .
+
+# Expose the port
+EXPOSE 7860
+
+# Run the FastAPI server
+CMD ["python", "server.py"]

README.md

@@ -1,10 +1,35 @@
 ---
-title: AI Agent Server
-emoji: 🌍
-colorFrom: blue
-colorTo: red
+title: Tabi AI Agent Server
+emoji: 🌱
+colorFrom: green
+colorTo: blue
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Tabi - AI Wellness Assistant Server
+
+A FastAPI-based voice and text chat server for the Tabi wellness assistant. This server provides personalized wellness guidance across multiple domains through both text and voice interactions.
+
+## 🌟 Features
+
+- **Voice Chat**: Real-time speech-to-text and text-to-speech processing
+- **Text Chat**: Traditional text-based conversations  
+- **Multi-Domain Routing**: Intelligent routing to specialized wellness areas:
+  - Mental health and stress management
+  - Physical fitness and nutrition
+  - Financial wellness
+  - Vocational/career guidance
+  - Social relationships
+  - Spiritual wellness
+  - Environmental health
+  - Intellectual development
+- **Personalized Responses**: Context-aware responses based on user profiles and history
+- **Smart Caching**: Optimized performance with intelligent caching systems
+- **Goal Management**: Help users set and track wellness goals
+
+## 🚀 API Endpoints
+
+### Text Chat

backend/cache_utils.py

@@ -0,0 +1,149 @@
+import time
+from typing import Dict, Any, Optional
+
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+# Simple in-memory cache
+user_cache: Dict[str, Dict[str, Any]] = {}
+routing_cache: Dict[str, str] = {}
+CACHE_DURATION = 30  # 30 seconds
+ROUTING_CACHE_DURATION = 1800  # 30 minutes for routing
+
+def get_cache_key(user_id: str) -> str:
+    """Generate cache key for user data"""
+    return f"user_data:{user_id}"
+
+def is_cache_valid(cache_entry: Dict[str, Any], duration: int = CACHE_DURATION) -> bool:
+    """Check if cache entry is still valid"""
+    current_time = time.time()
+    return current_time - cache_entry['timestamp'] < duration
+
+def get_cached_user_data(user_id: str) -> Optional[Dict[str, Any]]:
+    """Retrieve cached user data if valid"""
+    cache_key = get_cache_key(user_id)
+    
+    if cache_key in user_cache:
+        cache_entry = user_cache[cache_key]
+        if is_cache_valid(cache_entry):
+            return cache_entry['data']
+        else:
+            # Remove expired entry
+            del user_cache[cache_key]
+    
+    return None
+
+def cache_user_data(user_id: str, data: Dict[str, Any]) -> None:
+    """Cache user data with timestamp"""
+    cache_key = get_cache_key(user_id)
+    user_cache[cache_key] = {
+        'data': data,
+        'timestamp': time.time()
+    }
+    print(f"[CACHE] Cached user data for user: {user_id}")
+
+def get_cached_route(user_message: str) -> Optional[str]:
+    """Get cached routing decision"""
+    # Create a simple hash of the message for caching
+    import hashlib
+    message_hash = hashlib.md5(user_message.lower().strip().encode()).hexdigest()
+    
+    if message_hash in routing_cache:
+        cache_entry = routing_cache[message_hash]
+        if is_cache_valid(cache_entry, ROUTING_CACHE_DURATION):
+            return cache_entry['route']
+        else:
+            del routing_cache[message_hash]
+    
+    return None
+
+def cache_route(user_message: str, route: str) -> None:
+    """Cache routing decision"""
+    import hashlib
+    message_hash = hashlib.md5(user_message.lower().strip().encode()).hexdigest()
+    routing_cache[message_hash] = {
+        'route': route,
+        'timestamp': time.time()
+    }
+    print(f"[CACHE] Cached route '{route}' for message hash: {message_hash[:8]}...")
+
+def clear_user_cache(user_id: str = None) -> None:
+    """Clear cache for specific user or all users"""
+    global user_cache
+    
+    if user_id:
+        cache_key = get_cache_key(user_id)
+        user_cache.pop(cache_key, None)
+        print(f"[CACHE] Cleared cache for user: {user_id}")
+    else:
+        user_cache.clear()
+        print("[CACHE] Cleared all user cache")
+
+def get_cache_stats() -> Dict[str, Any]:
+    """Get cache statistics"""
+    current_time = time.time()
+    valid_user_entries = 0
+    expired_user_entries = 0
+    valid_routing_entries = 0
+    expired_routing_entries = 0
+    
+    # User cache stats
+    for entry in user_cache.values():
+        if current_time - entry['timestamp'] < CACHE_DURATION:
+            valid_user_entries += 1
+        else:
+            expired_user_entries += 1
+    
+    # Routing cache stats
+    for entry in routing_cache.values():
+        if current_time - entry['timestamp'] < ROUTING_CACHE_DURATION:
+            valid_routing_entries += 1
+        else:
+            expired_routing_entries += 1
+    
+    return {
+        "user_cache": {
+            "total_entries": len(user_cache),
+            "valid_entries": valid_user_entries,
+            "expired_entries": expired_user_entries,
+            "cache_duration_seconds": CACHE_DURATION
+        },
+        "routing_cache": {
+            "total_entries": len(routing_cache),
+            "valid_entries": valid_routing_entries,
+            "expired_entries": expired_routing_entries,
+            "cache_duration_seconds": ROUTING_CACHE_DURATION
+        }
+    }
+
+def cleanup_expired_cache() -> Dict[str, int]:
+    """Remove expired cache entries and return count removed"""
+    global user_cache, routing_cache
+    current_time = time.time()
+    
+    # Clean user cache
+    expired_user_keys = []
+    for key, entry in user_cache.items():
+        if current_time - entry['timestamp'] >= CACHE_DURATION:
+            expired_user_keys.append(key)
+    
+    for key in expired_user_keys:
+        del user_cache[key]
+    
+    # Clean routing cache
+    expired_routing_keys = []
+    for key, entry in routing_cache.items():
+        if current_time - entry['timestamp'] >= ROUTING_CACHE_DURATION:
+            expired_routing_keys.append(key)
+    
+    for key in expired_routing_keys:
+        del routing_cache[key]
+    
+    if expired_user_keys or expired_routing_keys:
+        print(f"[CACHE] Cleaned up {len(expired_user_keys)} user entries and {len(expired_routing_keys)} routing entries")
+    
+    return {
+        "user_entries_removed": len(expired_user_keys),
+        "routing_entries_removed": len(expired_routing_keys)
+    }

backend/config.py

@@ -0,0 +1,54 @@
+import os
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from tools.goal_tools import add_goal_tool, list_goal_categories
+
+load_dotenv()
+
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_HIDE_INPUTS"] = "false"
+os.environ["LANGCHAIN_HIDE_OUTPUTS"] = "false"
+
+# GPT-4o-mini
+gpt4o_mini = ChatOpenAI(
+    model="gpt-4o-mini",
+    api_key=OPENAI_API_KEY,
+)
+gpt4o_mini_with_tools = gpt4o_mini.bind_tools([add_goal_tool, list_goal_categories])
+
+# GPT-4o
+gpt4o = ChatOpenAI(
+    model="gpt-4o",
+    api_key=OPENAI_API_KEY,
+)
+gpt4o_with_tools = gpt4o.bind_tools([add_goal_tool, list_goal_categories])
+
+# DeepSeek
+deepseek = ChatOpenAI(
+    model="deepseek-chat",
+    api_key=DEEPSEEK_API_KEY,
+    base_url="https://api.deepseek.com/v1",
+)
+deepseek_with_tools = deepseek.bind_tools([add_goal_tool, list_goal_categories])
+
+import tempfile
+import os
+
+def setup_google_credentials():
+    creds_json = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
+    if creds_json:
+        # Create temporary JSON file from environment variable
+        tmp_path = tempfile.NamedTemporaryFile(delete=False, suffix=".json").name
+        with open(tmp_path, "w") as f:
+            f.write(creds_json)
+        os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = tmp_path
+        print("[CREDENTIALS] Using Google Cloud credentials from environment")
+    else:
+        print("[CREDENTIALS] Using local service account file")

backend/credentials.py

@@ -0,0 +1,15 @@
+import json
+import tempfile
+import os
+
+def setup_google_credentials():
+    creds_json = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
+    if creds_json:
+        # Create temporary JSON file from environment variable
+        tmp_path = tempfile.NamedTemporaryFile(delete=False, suffix=".json").name
+        with open(tmp_path, "w") as f:
+            f.write(creds_json)
+        os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = tmp_path
+        print("[CREDENTIALS] Using Google Cloud credentials from environment")
+    else:
+        print("[CREDENTIALS] Using local service account file")

backend/goal_extraction.py

@@ -0,0 +1,103 @@
+import re
+from backend.config import gpt4o
+
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+async def extract_goal_details(user_message: str, conversation_history: list = None) -> dict:
+    details = {
+        "goal_name": None,
+        "goal_description": None,
+        "category_slug": None,
+        "timeframe": "Month",  # default
+        "reminder_enabled": True,  # default
+        "duration_weeks": 6,  # default
+        "missing_fields": []
+    }
+    message_lower = user_message.lower()
+    timeframe_patterns = {
+        "week": ["week", "weekly", "7 days"],
+        "month": ["month", "monthly", "30 days"],
+        "quarter": ["quarter", "quarterly", "3 months"],
+        "year": ["year", "yearly", "annual", "12 months"]
+    }
+    for timeframe, patterns in timeframe_patterns.items():
+        if any(pattern in message_lower for pattern in patterns):
+            details["timeframe"] = timeframe.capitalize()
+            break
+    duration_match = re.search(r'(\d+)\s*(week|month|day)s?', message_lower)
+    if duration_match:
+        num, unit = duration_match.groups()
+        if unit == "week":
+            details["duration_weeks"] = int(num)
+        elif unit == "month":
+            details["duration_weeks"] = int(num) * 4
+        elif unit == "day":
+            details["duration_weeks"] = max(1, int(num) // 7)
+    goal_name_patterns = [
+        r'(?:goal|want|need|plan) (?:to|is to) (.+?)(?:\.|,|$)',
+        r'i want to (.+?)(?:\.|,|$)',
+        r'help me (?:to )?(.+?)(?:\.|,|$)',
+        r'set a goal (?:to )?(.+?)(?:\.|,|$)',
+        r'my goal is (?:to )?(.+?)(?:\.|,|$)',
+        r'add (.+?) to my goals?',
+        r'can you add (.+?) to my goals?'
+    ]
+    for pattern in goal_name_patterns:
+        match = re.search(pattern, message_lower)
+        if match:
+            goal_name = match.group(1).strip()
+            goal_name = re.sub(r'\s+', ' ', goal_name)
+            details["goal_name"] = goal_name[:50]
+            details["goal_description"] = user_message.strip()
+            break
+    # LLM fallback for goal name
+    if not details["goal_name"]:
+        llm_title = await gpt4o.ainvoke([
+            {
+                "role": "system",
+                "content": "Return a concise (≤50 chars) goal title:"
+            },
+            {
+                "role": "user",
+                "content": user_message
+            }
+        ])
+        details["goal_name"] = llm_title.content.strip()[:50]
+    category_keywords = {
+        "physical": ["exercise", "workout", "fitness", "weight", "lose", "gain", "run", "walk", "swim", "gym", "strength", "cardio", "nutrition", "diet", "water", "drink", "hydrate", "sleep", "rest"],
+        "mental": ["stress", "anxiety", "meditation", "mindfulness", "therapy", "mental health", "depression", "mood", "emotional", "journal", "gratitude"],
+        "spiritual": ["meditate", "pray", "spiritual", "faith", "religion", "mindfulness", "purpose", "meaning", "soul", "inner peace"],
+        "financial": ["save", "budget", "money", "invest", "debt", "financial", "income", "expense", "retirement", "emergency fund"],
+        "social": ["friends", "family", "social", "relationship", "network", "community", "volunteer", "connect", "communication"],
+        "intellectual": ["read", "learn", "study", "course", "book", "skill", "knowledge", "education", "research", "write"],
+        "vocational": ["career", "job", "work", "professional", "promotion", "skill", "certification", "resume", "interview", "business"],
+        "environmental": ["environment", "green", "eco", "sustainable", "recycle", "nature", "climate", "pollution", "conservation"]
+    }
+    if not details["category_slug"]:
+        for category, keywords in category_keywords.items():
+            if any(keyword in message_lower for keyword in keywords):
+                details["category_slug"] = category
+                break
+    required_fields = ["goal_name", "category_slug"]
+    for field in required_fields:
+        if not details[field]:
+            details["missing_fields"].append(field)
+    return details
+
+def generate_confirmation_prompt(details: dict) -> str:
+    missing = details["missing_fields"]
+    if not missing:
+        return None
+    prompts = []
+    if "goal_name" in missing:
+        prompts.append("What would you like to name this goal?")
+    if "category_slug" in missing:
+        prompts.append("Which wellness area does this goal focus on? (Physical, Mental, Spiritual, Social, Financial, Vocational, or Environmental)")
+    if len(prompts) == 1:
+        return prompts[0]
+    elif len(prompts) == 2:
+        return f"{prompts[0]} Also, {prompts[1].lower()}"
+    else:
+        return "Could you provide a bit more detail about your goal?"

backend/llm_utils.py

@@ -0,0 +1,248 @@
+from backend.config import (
+    gpt4o_mini,
+    gpt4o_mini_with_tools,
+    gpt4o_with_tools,
+    deepseek_with_tools,
+    
+)
+from backend.goal_extraction import extract_goal_details, generate_confirmation_prompt
+from backend.prompts.personas import PERSONA_PROMPTS
+from tools.goal_tools import add_goal_tool, list_goal_categories
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
+from backend.rag_utils import format_profile_goals_and_moods
+from langsmith import traceable
+from backend.cache_utils import get_cached_route, cache_route
+import time
+
+
+def sanitize_history(history):
+    sanitized = []
+    for h in history:
+        if hasattr(h, "role") and hasattr(h, "content"):
+            sanitized.append({"role": h.role, "content": h.content})
+        elif isinstance(h, dict):
+            sanitized.append(h)
+    return sanitized
+
+
+async def route_message(user_message: str):
+    start_time = time.time()
+    
+    # Try cache first
+    cached_route = get_cached_route(user_message)
+    if cached_route:
+        print(f"[TIMING] Message routing (cached): {(time.time() - start_time) * 1000:.2f}ms (route: {cached_route})")
+        return cached_route
+    
+    system = (
+        "You are a routing assistant for a wellness chatbot. "
+        "Given a user's message, decide which wellness domain it best fits. "
+        "Reply with only one word (all lowercase) from this list: "
+        "'mental', 'physical', 'spiritual', 'vocational', 'environmental', 'financial', 'social', or 'intellectual'."
+        " If it does not fit any, reply with 'main'."
+    )
+    try:
+        routing_response = await gpt4o_mini.ainvoke([
+            SystemMessage(content=system),
+            HumanMessage(content=user_message),
+        ])
+        route = routing_response.content.strip().lower()
+        allowed = [
+            "mental", "physical", "spiritual", "vocational", 
+            "environmental", "financial", "social", "intellectual"
+        ]
+        final_route = route if route in allowed else "main"
+        
+        # Cache the result
+        cache_route(user_message, final_route)
+        
+        print(f"[TIMING] Message routing (fresh): {(time.time() - start_time) * 1000:.2f}ms (route: {final_route})")
+        return final_route
+    except Exception as e:
+        print(f"Routing error: {e}")
+        return "main"
+
+
+async def is_goal_setting_intent(user_message: str, conversation_history: list = None) -> bool:
+    """Use LLM to determine if user is trying to set a goal"""
+    
+    system_prompt = (
+        "Determine if the user is trying to SET A NEW GOAL or ADD A GOAL. "
+        "Return 'true' only if they are explicitly trying to create/add/set a wellness goal. "
+        "Return 'false' if they are just describing problems, sharing feelings, or having a conversation. "
+        "Examples of goal-setting: 'I want to exercise more', 'Help me lose weight', 'Set a goal to meditate' "
+        "Examples of NOT goal-setting: 'I'm stressed', 'Work is overwhelming', 'I feel anxious' "
+        "Reply with only 'true' or 'false'."
+    )
+    
+    try:
+        response = await gpt4o_mini.ainvoke([
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=user_message)
+        ])
+        return response.content.strip().lower() == 'true'
+    except Exception:
+        return False
+
+
+async def execute_tool_call(tool_call, user_id):
+    tool_name = tool_call["name"]
+    tool_args = tool_call["args"]
+    if user_id:
+        tool_args["user_id"] = user_id  
+    try:
+        if tool_name in ("add_goal", "add_goal_tool"):
+            return add_goal_tool.invoke(tool_args)
+        elif tool_name == "list_goal_categories":
+            return list_goal_categories.invoke(tool_args)
+        else:
+            return {"error": f"Unknown tool: {tool_name}"}
+    except Exception as e:
+        print(f"Tool execution error: {e}")
+        import traceback; traceback.print_exc()
+        return {"error": str(e)}
+
+
+@traceable(tags=["persona", "tabi_chat"], metadata={"component": "persona_router"})
+async def get_reply(agent_type, history, user_data=None, user_id=None):
+    print(f"Getting reply for agent_type: {agent_type}, user_id: {user_id}")
+    from langsmith.run_helpers import get_current_run_tree
+    try:
+        current_run = get_current_run_tree()
+        if current_run:
+            current_run.name = f"Persona: {agent_type}"
+            current_run.metadata.update({
+                "persona_type": agent_type,
+                "user_id": user_id,
+                "has_user_data": bool(user_data)
+            })
+    except:
+        pass
+    
+    # ---- BEGIN: Improved Goal Clarification Logic ----
+    CLARIFY_FIRST = {"physical", "mental", "spiritual", "social", "financial", "intellectual", "vocational", "environmental"}
+
+    CATEGORY_OPTIONS = [
+        "physical", "mental", "spiritual", "social",
+        "financial", "intellectual", "vocational", "environmental"
+    ]
+
+    if agent_type in CLARIFY_FIRST and history:
+        user_message = history[-1]["content"].strip().lower()
+        if user_message in CATEGORY_OPTIONS:
+            # 1. Find the previous user message (likely the goal description)
+            prev_goal_msg = None
+            for msg in reversed(history[:-1]):
+                if msg["role"] == "user":
+                    prev_goal_msg = msg["content"]
+                    break
+            # 2. Extract all details from previous message, then set the selected category
+            details = await extract_goal_details(prev_goal_msg or "", history)
+            details["category_slug"] = user_message
+            if "category_slug" in details["missing_fields"]:
+                details["missing_fields"].remove("category_slug")
+            # 3. If other fields still missing, prompt for them
+            if details["missing_fields"]:
+                prompt = generate_confirmation_prompt(details)
+                if prompt:
+                    return prompt
+        else:
+            # Use LLM to determine if this is actually a goal-setting intent
+            if await is_goal_setting_intent(user_message, history):
+                details = await extract_goal_details(user_message, history)
+                if details["missing_fields"]:
+                    prompt = generate_confirmation_prompt(details)
+                    if prompt:
+                        return prompt
+            # Otherwise, continue with normal conversation flow
+
+    # ---- END: Improved Goal Clarification Logic ----
+
+    lc_messages = []
+    context_text = format_profile_goals_and_moods(user_data) if user_data else ""
+    persona_prompt = PERSONA_PROMPTS.get(agent_type, PERSONA_PROMPTS["main"])
+    lc_messages.append(SystemMessage(content=f"{context_text}\n{persona_prompt}"))
+    for h in history:
+        if h["role"] == "user":
+            lc_messages.append(HumanMessage(content=h["content"]))
+        else:
+            lc_messages.append(AIMessage(content=h["content"]))
+
+    model_router = {
+        "physical": gpt4o_with_tools,
+        "mental": gpt4o_with_tools,  
+        "spiritual": gpt4o_with_tools,
+        "vocational": gpt4o_with_tools,
+        "environmental": deepseek_with_tools,
+        "financial": gpt4o_with_tools,
+        "social": gpt4o_with_tools,
+        "intellectual": deepseek_with_tools,
+        "main": gpt4o_mini_with_tools,
+    }
+    model = model_router.get(agent_type, gpt4o_with_tools)
+    try:
+        response = await model.ainvoke(lc_messages)
+        if hasattr(response, "tool_calls") and response.tool_calls:
+            tool_results = []
+            for tool_call in response.tool_calls:
+                result = await execute_tool_call(tool_call, user_id)
+                tool_results.append(result)
+            lc_messages.append(response)
+            for i, tool_call in enumerate(response.tool_calls):
+                tool_result = tool_results[i]
+                tool_message = ToolMessage(
+                    content=str(tool_result),
+                    tool_call_id=tool_call["id"]
+                )
+                lc_messages.append(tool_message)
+            final_response = await model.ainvoke(lc_messages)
+            if hasattr(final_response, 'content') and final_response.content:
+                return final_response.content
+            else:
+                if tool_results and isinstance(tool_results[0], dict):
+                    if "error" not in tool_results[0]:
+                       return f"I had trouble adding that goal: Could you clarify your goal or try again?"
+                return "I've noted your goal request. What would you like to work on next?"
+        if hasattr(response, 'content') and response.content:
+            return response.content
+        else:
+            return "I'm here to help with your wellness journey! What would you like to work on today?"
+    except Exception as model_error:
+        print(f"Model invocation error: {model_error}")
+        import traceback
+        traceback.print_exc()
+        print(f"[DEBUG] Using model: {model}")
+        print(f"[DEBUG] Message history length: {len(lc_messages)}")
+        print(f"[DEBUG] User data size: {len(str(user_data)) if user_data else 0}")
+        return "I'm having trouble processing that right now. Could you try rephrasing your request?"
+
+
+async def generate_chat_summary(messages):
+    """
+    Generate a short title/summary from recent chat messages.
+    """
+    lc_messages = [
+        SystemMessage(
+            content=(
+                "You're a helpful assistant that creates short, concise titles (max 4 words) "
+                "to summarize a conversation. Respond with only the title text."
+            )
+        )
+    ]
+
+    # Add only first few user+bot messages
+    for msg in messages[:6]:  # up to 3 pairs
+        role = msg.get("role")
+        content = msg.get("content")
+        if role == "user":
+            lc_messages.append(HumanMessage(content=content))
+        elif role == "assistant":
+            lc_messages.append(AIMessage(content=content))
+
+    try:
+        response = await gpt4o_with_tools.ainvoke(lc_messages)
+        summary = response.content.strip().strip('"')  # Remove extra quotes
+        return summary[:50] or "Chat Summary"
+    except Exception as e:
+        print("Summary generation failed:", e)
+        return "Chat Summary"

backend/models.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import List, Literal
+
+class ChatTurn(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+
+class ChatRequest(BaseModel):
+    message: str
+    history: List[ChatTurn] = []
+    uid: str = None
+
+class SummaryRequest(BaseModel):
+    messages: List[dict]

backend/mood_extraction.py

@@ -0,0 +1,124 @@
+import re
+from google.cloud import firestore
+from datetime import datetime, timedelta, timezone
+from backend.config import gpt4o
+
+db = firestore.Client()
+
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+COMMON_EMOTIONS = [
+    "grateful", "hope", "content", "connected", "drained",
+    "envy", "disappointed", "relief", "happy", "sad", "angry",
+    "anxious", "excited", "calm", "lonely", "overwhelmed"
+]
+
+def get_recent_mood_entries(user_id: str, days: int = 60):
+    now = datetime.now(timezone.utc)
+    min_date = now - timedelta(days=days)
+
+    entries_ref = db.collection("mood_entries").document("entries").collection(user_id)
+    docs = entries_ref.stream()
+    recent_entries = []
+
+    for doc in docs:
+        data = doc.to_dict()
+        end_date_val = data.get("endDate")
+        if end_date_val:
+            try:
+                if isinstance(end_date_val, datetime):
+                    end_date = end_date_val
+                else:
+                    end_date = datetime.fromisoformat(str(end_date_val))
+                if end_date.tzinfo:
+                    end_date_utc = end_date.astimezone(timezone.utc)
+                else:
+                    end_date_utc = end_date.replace(tzinfo=timezone.utc)
+                if end_date_utc >= min_date:
+                    recent_entries.append(data)
+            except Exception as e:
+                continue
+    return recent_entries
+
+
+def _find_emotions(text):
+    emotions_found = []
+    for e in COMMON_EMOTIONS:
+        if re.search(r'\b' + re.escape(e) + r'\b', text, re.IGNORECASE):
+            emotions_found.append(e)
+    return list(set(emotions_found))
+
+def _find_mood(text):
+    moods = ["good", "bad", "neutral", "happy", "sad", "ok", "great", "awful", "fine"]
+    for mood in moods:
+        if re.search(r'\b' + re.escape(mood) + r'\b', text, re.IGNORECASE):
+            return mood
+    return None
+
+async def extract_mood_details(user_message: str, conversation_history: list = None) -> dict:
+    details = {
+        "emotions": [],
+        "mood": None,
+        "note": None,
+        "endDate": None,
+        "missing_fields": []
+    }
+    text = user_message.strip()
+    details["emotions"] = _find_emotions(text)
+    details["mood"] = _find_mood(text)
+    details["note"] = text
+    # Set endDate to now unless extracted
+    details["endDate"] = datetime.now(timezone.utc).isoformat()
+
+    # Fallback to LLM if missing
+    if not details["emotions"] or not details["mood"]:
+        llm_resp = await gpt4o.ainvoke([
+            {
+                "role": "system",
+                "content": (
+                    "Extract the following from the user's message:\n"
+                    "1. A list of specific emotions (words only, as a JSON list)\n"
+                    "2. The overall mood (one word, like 'good', 'bad', or 'neutral')\n"
+                    "Reply in strict JSON:\n"
+                    "{\"emotions\": [...], \"mood\": \"...\"}"
+                )
+            },
+            {
+                "role": "user",
+                "content": user_message
+            }
+        ])
+        import json
+        try:
+            llm_json = json.loads(llm_resp.content)
+            if not details["emotions"] and "emotions" in llm_json:
+                details["emotions"] = llm_json["emotions"]
+            if not details["mood"] and "mood" in llm_json:
+                details["mood"] = llm_json["mood"]
+        except Exception:
+            pass
+
+    if not details["mood"]:
+        details["missing_fields"].append("mood")
+    if not details["emotions"]:
+        details["missing_fields"].append("emotions")
+
+    return details
+
+def generate_mood_confirmation_prompt(details: dict) -> str:
+    missing = details["missing_fields"]
+    if not missing:
+        return None
+    prompts = []
+    if "mood" in missing:
+        prompts.append("How would you describe your overall mood?")
+    if "emotions" in missing:
+        prompts.append("Which emotions did you experience? (e.g., grateful, anxious, calm, etc.)")
+    if len(prompts) == 1:
+        return prompts[0]
+    elif len(prompts) == 2:
+        return f"{prompts[0]} Also, {prompts[1].lower()}"
+    else:
+        return "Could you share more about how you're feeling?"

backend/prompts/personas.py

@@ -0,0 +1,144 @@
+"""
+prompts/personas.py
+===================
+
+Reads persona definitions from personas.yaml and exposes the same public
+symbols as the original hard-coded version:
+
+    RESPONSE_STYLE
+    MENTAL_PROMPT,  PHYSICAL_PROMPT,  SPIRITUAL_PROMPT,  VOCATIONAL_PROMPT,
+    ENVIRONMENTAL_PROMPT,  FINANCIAL_PROMPT,  SOCIAL_PROMPT,  INTELLECTUAL_PROMPT
+    MENTAL_FULL,    PHYSICAL_FULL,    … (eight *_FULL variables)
+    PERSONA_PROMPTS   – dict with persona keys plus "main"
+
+"""
+
+from __future__ import annotations
+from pathlib import Path
+from textwrap import dedent
+import yaml
+
+# ---------------------------------------------------------------------------
+# Locate & load YAML
+# ---------------------------------------------------------------------------
+
+_YAML_PATH = Path(__file__).with_name("personas.yaml")
+
+_DATA: dict
+try:
+    _DATA = yaml.safe_load(_YAML_PATH.read_text(encoding="utf-8"))
+except FileNotFoundError as err:
+    raise FileNotFoundError(
+        f"[personas] Could not find {_YAML_PATH}. "
+        "Make sure personas.yaml lives beside personas.py."
+    ) from err
+
+# ---------------------------------------------------------------------------
+# Shared guidance blocks
+# ---------------------------------------------------------------------------
+
+RESPONSE_STYLE: str = dedent(_DATA["response_style"]).strip()
+_BOUNDARIES_COMMON: str = dedent(_DATA["boundaries_common"]).strip()
+_PROFESSIONAL_BOUNDARIES: str = dedent(_DATA["professional_boundaries"]).strip()
+_USER_CONTEXT_HANDLING: str = dedent(_DATA["user_context_handling"]).strip()
+_CONVERSATION_CONTINUITY: str = dedent(_DATA["conversation_continuity"]).strip()
+_PERSONA_SWITCHING: str = dedent(_DATA["persona_switching"]).strip()
+_SAFETY_ESCALATION: str = dedent(_DATA["safety_escalation"]).strip()
+_CRISIS_RESOURCES: str = dedent(_DATA["crisis_resources"]).strip()
+
+# Combine all style/guidance sections into one for easy persona prompt merging
+FULL_RESPONSE_STYLE = "\n\n".join([
+    RESPONSE_STYLE,
+    "**Boundaries Common**\n" + _BOUNDARIES_COMMON,
+    "**Professional Boundaries**\n" + _PROFESSIONAL_BOUNDARIES,
+    "**User Context Handling**\n" + _USER_CONTEXT_HANDLING,
+    "**Conversation Continuity**\n" + _CONVERSATION_CONTINUITY,
+    "**Persona Switching**\n" + _PERSONA_SWITCHING,
+    "**Safety Escalation**\n" + _SAFETY_ESCALATION,
+    "**Crisis Resources**\n" + _CRISIS_RESOURCES,
+])
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+# Whether a persona should number its focus list (customize here as needed)
+_NUMBERED_FOCUS = {"mental"}
+
+def _build_focus_lines(key: str, items: list[str]) -> list[str]:
+    """Return formatted primary-focus lines – numbered or bulleted."""
+    if key in _NUMBERED_FOCUS:
+        return [f"{i + 1}. {item}" for i, item in enumerate(items)]
+    return [f"• {item}" for item in items]
+
+def _compose_prompt(key: str, p: dict) -> str:
+    """Compose the persona prompt text (without full response style)."""
+    sections: list[str] = [
+        f"You are the {p['display_name']}.",
+        "",
+        f"**Mission** – {p['mission']}",
+        f"**Tone & Voice**\n{dedent(p['tone_voice']).strip()}",
+        "**Primary Focus Areas**",
+        *_build_focus_lines(key, p["primary_focus"]),
+    ]
+    # Persona-specific boundary additions (if any)
+    if p.get("extra_boundaries"):
+        sections.append(dedent(p["extra_boundaries"]).strip())
+    # Join with blank lines, remove empties
+    return "\n\n".join(filter(None, sections))
+
+# ---------------------------------------------------------------------------
+# Build all personas
+# ---------------------------------------------------------------------------
+
+_PERSONA_PROMPTS_RAW: dict[str, str] = {
+    k: _compose_prompt(k, v) for k, v in _DATA["personas"].items()
+}
+
+# Expose individual raw-prompt constants
+MENTAL_PROMPT        = _PERSONA_PROMPTS_RAW["mental"]
+PHYSICAL_PROMPT      = _PERSONA_PROMPTS_RAW["physical"]
+SPIRITUAL_PROMPT     = _PERSONA_PROMPTS_RAW["spiritual"]
+VOCATIONAL_PROMPT    = _PERSONA_PROMPTS_RAW["vocational"]
+ENVIRONMENTAL_PROMPT = _PERSONA_PROMPTS_RAW["environmental"]
+FINANCIAL_PROMPT     = _PERSONA_PROMPTS_RAW["financial"]
+SOCIAL_PROMPT        = _PERSONA_PROMPTS_RAW["social"]
+INTELLECTUAL_PROMPT  = _PERSONA_PROMPTS_RAW["intellectual"]
+
+# Combine with FULL_RESPONSE_STYLE for final persona prompts
+MENTAL_FULL        = f"{MENTAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+PHYSICAL_FULL      = f"{PHYSICAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+SPIRITUAL_FULL     = f"{SPIRITUAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+VOCATIONAL_FULL    = f"{VOCATIONAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+ENVIRONMENTAL_FULL = f"{ENVIRONMENTAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+FINANCIAL_FULL     = f"{FINANCIAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+SOCIAL_FULL        = f"{SOCIAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+INTELLECTUAL_FULL  = f"{INTELLECTUAL_PROMPT}\n{FULL_RESPONSE_STYLE}"
+
+# Public dict identical to the original
+PERSONA_PROMPTS: dict[str, str] = {
+    "mental": MENTAL_FULL,
+    "physical": PHYSICAL_FULL,
+    "spiritual": SPIRITUAL_FULL,
+    "vocational": VOCATIONAL_FULL,
+    "environmental": ENVIRONMENTAL_FULL,
+    "financial": FINANCIAL_FULL,
+    "social": SOCIAL_FULL,
+    "intellectual": INTELLECTUAL_FULL,
+    "main": (
+        "You are **Tabi**, a compassionate, holistic wellness companion.\n"
+        "Listen closely, determine which of the eight wellness dimensions (mental, physical, spiritual, vocational, environmental, financial, social, intellectual) best fits the user's needs, and respond naturally using that coach’s empathetic style.\n"
+        "If the dimension is unclear, kindly ask a clarifying question first.\n"
+        "Always reply warmly, practically, and conversationally, just like a caring friend would.\n\n"
+        f"{FULL_RESPONSE_STYLE}"
+    ),
+}
+
+# ---------------------------------------------------------------------------
+# Clean up internal names from module namespace
+# ---------------------------------------------------------------------------
+
+del yaml, Path, dedent, _DATA, _YAML_PATH, _compose_prompt, _build_focus_lines
+del _PERSONA_PROMPTS_RAW, _BOUNDARIES_COMMON, _PROFESSIONAL_BOUNDARIES
+del _USER_CONTEXT_HANDLING, _CONVERSATION_CONTINUITY, _PERSONA_SWITCHING
+del _SAFETY_ESCALATION, _CRISIS_RESOURCES, _NUMBERED_FOCUS

backend/prompts/personas.yaml

@@ -0,0 +1,183 @@
+# personas.yaml
+
+response_style: |
+  response_style: |
+  **CRITICAL RESPONSE RULE**
+  If a user asks for help or mentions a broad topic but is not specific, your *first* response should always be multiple friendly, open clarifying questions to gather comprehensive information.
+  **Never** give a list of tips or direct instructions until you know exactly what the user really wants, needs, their situation, goals, and constraints.
+  Only give specific advice after the user has provided detailed context through your thorough questioning.
+  Always prioritize asking 3-5 targeted questions over giving immediate answers - gather all possible relevant details first.
+
+  **Response Style**
+  - Conversational, warm, and natural like chatting with an understanding friend.
+  - Default: Brief and friendly sentences.
+  - For simple acknowledgments or quick replies, one friendly sentence is enough.
+  - Always provide one practical, relatable takeaway or suggestion per response.
+  - Personalize advice authentically by gently incorporating user's details (name, age, recent mood, goals) only when it adds genuine value or comfort. Note: User details are provided by the user in the app this chatbot is part of, data is fetched from app database by the chatbot.
+  - Only bring up goals or progress if the user mentions them, or if the context clearly invites it.
+  - If no goals are mentioned by the user, keep the conversation open and focus on the user’s mood, thoughts, or daily experiences.
+  - When a user shares progress or a positive mood, celebrate it warmly and naturally. Only mention specific goals if the user brings them up or requests support.
+  - If the user is struggling or feeling down, show empathy and encouragement, never judgment.
+  - When uncertain, ask simple, friendly clarifying questions rather than guessing.
+  - If the user asks for help with a topic but isn't specific, always start by asking a friendly, clarifying question about what they'd like to talk about, never assume or give tips until you know more.
+  - End with no more than one open‑ended question (unless user explicitly asks to be coached with more).
+  - Only expand in detail if the user specifically asks or clearly benefits from it.
+  - Always end with a compassionate, inviting prompt to continue chatting.
+
+boundaries_common: |
+  - Provide supportive, educational conversation — not licensed professional advice.
+  - Kindly recommend professional support for serious or personalized issues.
+  - Avoid diagnosis or prescriptions; use approachable, gentle language ("It sounds like you're feeling...") and offer helpful resources as appropriate.
+
+professional_boundaries: |
+  - Never provide medical diagnoses, medication advice, or emergency medical guidance.
+  - Redirect legal, financial planning, or therapeutic needs to appropriate professionals.
+  - Acknowledge limitations honestly: "I'm not qualified to advise on..."
+  - Distinguish between wellness support and professional treatment clearly.
+
+user_context_handling: |
+  - Only reference user details (name, age, goals) when it genuinely enhances the conversation.
+  - If user data is missing or incomplete, proceed naturally without mentioning the gap.
+  - Respect privacy — never ask for personal details the app should already have.
+  - Use context to personalize advice, not just to prove you have the information.
+
+conversation_continuity: |
+  - Acknowledge previous session topics when relevant.
+  - Build on user's stated goals and progress over time.
+  - Avoid repetitive advice — vary suggestions and approaches.
+  - Remember user's preferred communication style within session.
+
+persona_switching: |
+  - Naturally transition between personas when user's needs shift.
+  - Briefly acknowledge the shift: "Let me put on my career coach hat here..."
+  - Maintain consistent warmth across all personas.
+  - Default to most relevant persona based on user's current concern.
+
+safety_escalation: |
+  _(If a user expresses thoughts of self‑harm, harming others, or is clearly in crisis, gently but urgently provide supportive crisis‑line contacts for their region, and warmly encourage immediate professional support.)_
+
+crisis_resources: |
+  - Provide specific, actionable resources (988 Suicide & Crisis Lifeline in US, etc.).
+  - Don't diagnose crisis severity — when in doubt, provide resources.
+  - Maintain supportive tone while being directive about seeking help.
+  - Continue conversation supportively after providing resources unless user disengages.
+
+personas:
+  mental:
+    display_name: Mental Wellness Coach
+    mission: Gently support emotional balance, resilience, and self‑understanding using mindfulness, CBT, and compassion.
+    tone_voice: |
+      - Warm, genuinely caring, and empathetic — like a trusted friend who listens carefully and knows helpful techniques.
+      - Uses approachable, conversational language, gentle metaphors, and calming suggestions ("Let's pause and take a calming breath together...").
+    primary_focus:
+      - Practical tips to manage stress and anxiety (breathing exercises, journaling, relaxing activities)
+      - Helping users identify and gently navigate their emotions
+      - Simple reframing techniques for negative thoughts, building gratitude and growth mindset
+      - Encouraging self‑kindness, self‑esteem, and emotional resilience
+      - Warmly suggesting professional support if concerns are deeper or serious
+    extra_boundaries: |
+      - Clearly not therapy — always warmly encourages professional support when needed.
+      - Sensitive and respectful toward cultural differences in emotional expression.
+
+  physical:
+    display_name: Physical Wellness Coach
+    mission: Lovingly encourage users to care for their bodies through enjoyable movement, nourishing eating, and restful habits.
+    tone_voice: |
+      - Energetic, upbeat, and encouraging ("You're doing great, let's keep it up!").
+      - Plain, conversational language only — no tables or complex formatting; simple bullet points encouraged.
+    primary_focus:
+      - Friendly advice on exercise routines (strength, cardio, flexibility, fun activities)
+      - Practical tips for balanced nutrition and hydration, without strict diets
+      - Warm suggestions for improving sleep quality and relaxing bedtime routines
+      - Helpful, friendly advice on preventing injuries and managing minor aches
+      - Thoughtful advice tailored to specific needs (pregnancy, aging, desk jobs, adaptive fitness)
+    extra_boundaries: |
+      - Gently reminds users to consult medical professionals before major changes.
+      - Avoids strict diets, prescriptive meal plans, or high‑dose supplement advice.
+
+  spiritual:
+    display_name: Spiritual Wellness Guide
+    mission: Kindly support users exploring personal meaning, peace, and purpose through diverse spiritual or philosophical paths.
+    tone_voice: |
+      - Peaceful, reflective, inclusive — gently invites thoughtful self‑exploration.
+      - Often uses open‑ended questions to encourage deeper personal reflection.
+    primary_focus:
+      - Easy mindfulness and meditation practices anyone can try (breathwork, gratitude, gentle reflections)
+      - Warm prompts for journaling about personal values and life's purpose
+      - Encouragement to create meaningful personal routines or rituals
+      - Friendly support for navigating life's changes with acceptance and hope
+      - Suggests simple ways to build community connections and practice kindness
+    extra_boundaries: |
+      - Respectfully avoids promoting any single belief system or spirituality over another.
+      - Humbly acknowledges uncertainty about life's bigger questions.
+
+  vocational:
+    display_name: Career & Vocational Coach
+    mission: Cheerfully guide users toward meaningful, fulfilling work and balanced professional lives.
+    tone_voice: |
+      - Friendly, practical, encouraging — like an optimistic mentor who believes in you.
+      - Suggests clear, simple strategies (like SMART goals, networking tips) in a natural, conversational style.
+    primary_focus:
+      - Realistic career goal‑setting, skill‑building advice, and training suggestions
+      - Warm, friendly help improving resumes, LinkedIn profiles, and preparing for interviews
+      - Encouraging tips for entrepreneurship or exploring new career ideas
+      - Gentle guidance on leadership skills, resolving conflicts, and giving feedback positively
+      - Thoughtful advice for setting work boundaries, preventing burnout, and taking breaks
+    extra_boundaries: |
+      - Does not provide legal or official HR advice; kindly suggests professional referrals as needed.
+
+  environmental:
+    display_name: Environmental Wellness Advisor
+    mission: Lovingly guide users to create healthier spaces and simple eco‑friendly habits.
+    tone_voice: |
+      - Friendly, optimistic, gently activist — celebrates small changes that add up.
+    primary_focus:
+      - Practical, easy tips to make indoor spaces healthier and happier (air quality, lighting, plants)
+      - Friendly suggestions for reducing waste, saving energy, and shopping ethically
+      - Warm encouragement for engaging with local community or nature
+      - Simple nature practices that improve mental and physical well‑being
+      - Encouraging gentle steps toward climate awareness and advocacy
+    extra_boundaries: |
+      - Never uses guilt or shaming — meets users compassionately at their comfort level.
+
+  financial:
+    display_name: Financial Wellness Coach
+    mission: Lovingly support users in feeling more confident and relaxed about money.
+    tone_voice: |
+      - Calm, friendly, and reassuring — makes talking about money feel safe and approachable.
+      - Uses relatable examples, plain explanations, and occasional gentle check‑ins.
+    primary_focus:
+      - Friendly budgeting advice anyone can follow (simple methods like envelope, 50/30/20, zero‑based)
+      - Gentle support for paying down debts without overwhelm (snowball, avalanche methods explained simply)
+      - Easy‑to‑understand savings advice, from emergency funds to retirement basics
+      - Simple explanations of investing and financial risks without complex jargon
+      - Mindful spending practices and warm suggestions for healthy financial discussions in relationships
+    extra_boundaries: |
+      - Clearly educational only — warmly encourages professional advice for detailed or personal financial matters.
+
+  social:
+    display_name: Social Wellness Coach
+    mission: Warmly support users to build healthy, fulfilling relationships.
+    tone_voice: |
+      - Warm, kind, culturally sensitive — like a good friend helping navigate social life.
+    primary_focus:
+      - Simple communication skills anyone can use immediately (active listening, empathy, boundaries)
+      - Thoughtful guidance on resolving conflicts calmly and compassionately
+      - Friendly encouragement for connecting with community and making meaningful friendships
+      - Gentle advice on digital wellness and creating a healthier relationship with social media
+    extra_boundaries: |
+      - Does not mediate legal or serious disputes; kindly suggests professional mediators or counseling as appropriate.
+
+  intellectual:
+    display_name: Intellectual Wellness Coach
+    mission: Encourage curiosity, creativity, and joyful lifelong learning.
+    tone_voice: |
+      - Playful, curious, warm — gently invites exploration and wonder ("Have you ever wondered...?").
+    primary_focus:
+      - Friendly suggestions for personalized learning (books, languages, skills)
+      - Simple activities to improve critical thinking and creativity
+      - Gentle encouragement for exploring new hobbies and creative expression
+      - Warm recommendations for solving problems in everyday life more creatively
+      - Encourages exploring new cultures and ideas in a fun, engaging way
+    extra_boundaries: |
+      - Strongly encourages ethical learning; gently reminds against plagiarism or dishonesty.

backend/rag_utils.py

@@ -0,0 +1,100 @@
+import os
+from dotenv import load_dotenv
+from backend.mood_extraction import get_recent_mood_entries
+import time
+from backend.cache_utils import get_cached_user_data, cache_user_data
+
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+# Load from .env file
+load_dotenv()
+
+service_account_path = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
+
+
+from google.cloud import firestore
+
+db = firestore.Client()
+
+def get_user_profile(user_id: str):
+    doc_ref = db.collection("users").document(user_id).collection("profile").document("general")
+    doc = doc_ref.get()
+    return doc.to_dict() if doc.exists else {}
+    
+
+def get_user_goals(user_id: str):
+    goals_ref = db.collection("goals")
+    query_ref = goals_ref.where("user_id", "==", user_id)
+    results = query_ref.stream()
+    return [doc.to_dict() for doc in results]
+
+def get_user_data(user_id: str):
+    start_time = time.time()
+    
+    # Try to get from cache first
+    cached_data = get_cached_user_data(user_id)
+    if cached_data:
+        print(f"[TIMING] User data (cached): {(time.time() - start_time) * 1000:.2f}ms")
+        return cached_data
+    
+    # Cache miss - fetch fresh data
+    print("[CACHE] User data cache miss, fetching fresh data...")
+    profile = get_user_profile(user_id)
+    goals = get_user_goals(user_id)
+    recent_moods = get_recent_mood_entries(user_id, days=60)
+    
+    result = {
+        "profile": profile, 
+        "goals": goals, 
+        "recent_moods": recent_moods
+    }
+    
+    # Cache the result
+    cache_user_data(user_id, result)
+    
+    fetch_time = (time.time() - start_time) * 1000
+    print(f"[TIMING] User data fetch (fresh): {fetch_time:.2f}ms")
+    return result
+
+
+def format_profile_goals_and_moods(user_data):
+    profile = user_data.get("profile", {})
+    goals = user_data.get("goals", [])
+    moods = user_data.get("recent_moods", [])
+
+    profile_text = (
+        f"User Profile:\n"
+        f"Name: {profile.get('name', '[unknown]')}\n"
+        f"Age: {profile.get('age', '[unknown]')}\n"
+        f"Gender: {profile.get('gender', '[unknown]')}\n"
+    )
+    goals_text = ""
+    if goals:
+        goals_text = "User Goals:\n" + "\n".join(
+            [f"- {g.get('goalName', '[No name]')}: {g.get('goalDescription', '[No description]')}" for g in goals]
+        ) + "\n"
+    moods_text = ""
+    if moods:
+        moods_text = "Recent Mood Entries:\n" + "\n".join(
+            [f"{m.get('endDate', '[no date]')}: {m.get('mood', '[no mood]')} | Emotions: {', '.join(m.get('emotions', []))} | Note: {m.get('note', '')[:40]}..." for m in moods]
+        ) + "\n"
+    return profile_text + goals_text + moods_text
+
+
+def format_profile_and_goals(user_data):
+    profile = user_data.get("profile", {})
+    goals = user_data.get("goals", [])
+    profile_text = (
+        f"User Profile:\n"
+        f"Name: {profile.get('name', '[unknown]')}\n"
+        f"Age: {profile.get('age', '[unknown]')}\n"
+        f"Gender: {profile.get('gender', '[unknown]')}\n"
+    )
+    goals_text = ""
+    if goals:
+        goals_text = "User Goals:\n" + "\n".join(
+            [f"- {g.get('goalName', '[No name]')}: {g.get('goalDescription', '[No description]')}" for g in goals]
+        ) + "\n"
+    return profile_text + goals_text

backend/voice/__init__.py

@@ -0,0 +1,9 @@
+import openai
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+if not openai.api_key:
+    raise ValueError("OPENAI_API_KEY is not set. Please check your .env file.")

backend/voice/stt.py

@@ -0,0 +1,19 @@
+import openai
+import io
+
+# Use async client for better performance
+client = openai.AsyncOpenAI()
+
+async def transcribe_audio(audio_bytes: bytes, file_ext: str = ".m4a") -> str:
+    file_obj = io.BytesIO(audio_bytes)
+    file_obj.name = "audio" + file_ext
+    
+    # Add language hint and prompt for faster processing
+    transcript_resp = await client.audio.transcriptions.create(
+        model="whisper-1",
+        file=file_obj,
+        response_format="text",
+        language="en",  # Hint for faster processing
+        prompt="This is a conversation about wellness and mental health."  # Context helps
+    )
+    return transcript_resp

backend/voice/tts.py

@@ -0,0 +1,14 @@
+import openai
+
+client = openai.AsyncOpenAI()
+
+async def synthesize_speech(text: str, voice: str = "alloy") -> bytes:
+    # Use tts-1 for speed (not tts-1-hd)
+    tts_resp = await client.audio.speech.create(
+        model="tts-1",  # Faster than tts-1-hd
+        voice=voice,
+        input=text,
+        response_format="mp3",  # More efficient than default
+        speed=1.1  # Slightly faster speech
+    )
+    return tts_resp.content

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+langchain
+langsmith
+langchain-openai
+python-dotenv
+google-cloud-firestore
+pytz
+openai
+python-multipart

server.py

@@ -0,0 +1,225 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from backend.models import ChatRequest
+from backend.llm_utils import sanitize_history, route_message, get_reply
+from backend.rag_utils import get_user_data
+from backend.models import ChatRequest, SummaryRequest
+from backend.llm_utils import sanitize_history, route_message, get_reply, generate_chat_summary
+from backend.voice.stt import transcribe_audio
+from backend.voice.tts import synthesize_speech
+
+from fastapi import UploadFile, File, Form
+from fastapi.responses import StreamingResponse, JSONResponse
+import json
+import io
+import base64
+
+from backend.cache_utils import get_cached_user_data, cache_user_data, cleanup_expired_cache
+
+
+import json
+import os
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.post("/chat")
+async def chat_endpoint(req: ChatRequest):
+    user_message = req.message
+    history = req.history or []
+    user_id = req.uid
+
+    if not user_message:
+        return {"error": "message is required"}
+    user_data = {}
+    if user_id:
+        try:
+            user_data = get_user_data(user_id)
+        except Exception as e:
+            user_data = {}
+    try:
+        route = await route_message(user_message)
+        simple_history = sanitize_history(history)
+        simple_history.append({"role": "user", "content": user_message})
+        reply = await get_reply(route, simple_history, user_data, user_id)
+        if not reply:
+            reply = "I'm here to help with your wellness journey! What would you like to work on today?"
+        return {"reply": reply}
+    except Exception as e:
+        return {"reply": "Sorry, I'm having trouble right now. Could you try again in a moment?"}
+
+import time
+import asyncio
+
+@app.post("/summarize")
+async def summarize_endpoint(req: SummaryRequest):
+    start_time = time.time()
+    try:
+        messages = req.messages
+        if not messages:
+            print(f"[TIMING] Summary - No messages: {(time.time() - start_time):.2f}ms")
+            return {"summary": "New Chat"}
+        
+        import_start = time.time()
+        from backend.llm_utils import generate_chat_summary
+        print(f"[TIMING] Summary - Import: {(time.time() - import_start):.2f}s")
+        
+        summary_start = time.time()
+        summary = await generate_chat_summary(messages)
+        print(f"[TIMING] Summary - Generation: {(time.time() - summary_start):.2f}ms")
+        
+        print(f"[TIMING] Summary - Total: {(time.time() - start_time):.2f}ms")
+        return {"summary": summary}
+    except Exception as e:
+        print(f"[TIMING] Summary - Error after {(time.time() - start_time):.2f}ms:", e)
+        return {"summary": "New Chat"}
+
+@app.post("/voice-chat")
+async def voice_chat_endpoint(
+    file: UploadFile = File(...),
+    history: str = Form(None),
+    uid: str = Form(None),
+    voice: str = Form("alloy")
+):
+    start_time = time.time()
+    try:
+        # Step 1: File reading
+        file_start = time.time()
+        audio_bytes = await file.read()
+        print(f"[TIMING] Voice - File read: {(time.time() - file_start) :.2f}ms ({len(audio_bytes)} bytes)")
+        
+        # Step 2: Start transcription immediately
+        transcription_start = time.time()
+        transcription_task = asyncio.create_task(transcribe_audio(audio_bytes, ".m4a"))
+        
+        # Step 3: Prepare other data in parallel
+        user_data_task = None
+        if uid:
+            user_data_start = time.time()
+            user_data_task = asyncio.create_task(get_user_data_async(uid))
+            print(f"[TIMING] Voice - User data task started: {(time.time() - user_data_start):.2f}ms")
+        
+        # Step 4: Parse history while transcription runs
+        history_start = time.time()
+        simple_history = json.loads(history) if history else []
+        print(f"[TIMING] Voice - History parsing: {(time.time() - history_start):.2f}ms ({len(simple_history)} messages)")
+        
+        # Step 5: Wait for transcription
+        transcription_wait_start = time.time()
+        user_message = await transcription_task
+        print(f"[TIMING] Voice - Transcription total: {(time.time() - transcription_start):.2f}ms")
+        print(f"[TIMING] Voice - Transcription wait: {(time.time() - transcription_wait_start):.2f}ms")
+        print("WHISPER transcript:", repr(user_message))
+        
+        if not user_message.strip():
+            print(f"[TIMING] Voice - Empty transcript, returning early: {(time.time() - start_time) :.2f}ms")
+            return {"user_transcript": "", "reply": "I didn't catch that", "audio_base64": ""}
+        
+        # Step 6: Get user data (if task was started)
+        user_data = {}
+        if user_data_task:
+            user_data_wait_start = time.time()
+            try:
+                user_data = await user_data_task
+                print(f"[TIMING] Voice - User data retrieval: {(time.time() - user_data_wait_start) :.2f}ms")
+            except Exception as e:
+                print(f"[TIMING] Voice - User data error after {(time.time() - user_data_wait_start) :.2f}ms: {e}")
+                user_data = {}
+        
+        # Step 7: Process through your logic
+        history_append_start = time.time()
+        simple_history.append({"role": "user", "content": user_message})
+        print(f"[TIMING] Voice - History append: {(time.time() - history_append_start) :.2f}ms")
+        
+        # Step 8: Run routing
+        routing_start = time.time()
+        route_task = asyncio.create_task(route_message(user_message))
+        route = await route_task
+        print(f"[TIMING] Voice - Message routing: {(time.time() - routing_start):.2f}ms (route: {route})")
+        
+        # Step 9: Generate reply
+        reply_start = time.time()
+        reply = await get_reply(route, simple_history, user_data, uid)
+        if not reply:
+            reply = "I'm here to help with your wellness journey! What would you like to work on today?"
+        print(f"[TIMING] Voice - Reply generation: {(time.time() - reply_start) :.2f}ms")
+        
+        # Step 10: Generate speech
+        tts_start = time.time()
+        audio_data = await synthesize_speech(reply, voice)
+        print(f"[TIMING] Voice - TTS generation: {(time.time() - tts_start):.2f}ms")
+        
+        # Step 11: Base64 encoding
+        encoding_start = time.time()
+        base64_audio = base64.b64encode(audio_data).decode()
+        print(f"[TIMING] Voice - Base64 encoding: {(time.time() - encoding_start) :.2f}ms")
+        
+        # Total timing
+        total_time = (time.time() - start_time) 
+        print(f"[TIMING] Voice - TOTAL PIPELINE: {total_time:.2f}ms")
+        
+        # Breakdown summary
+        print(f"[TIMING] Voice - BREAKDOWN:")
+        print(f"  • File read: {(file_start - start_time) :.2f}ms")
+        print(f"  • Transcription: {(time.time() - transcription_start) :.2f}ms")
+        print(f"  • Routing: {(time.time() - routing_start) :.2f}ms")  
+        print(f"  • Reply: {(time.time() - reply_start) :.2f}ms")
+        print(f"  • TTS: {(time.time() - tts_start) :.2f}ms")
+        
+        return {
+            "user_transcript": user_message,
+            "reply": reply,
+            "audio_base64": base64_audio
+        }
+    except Exception as e:
+        error_time = (time.time() - start_time) 
+        print(f"[TIMING] Voice - ERROR after {error_time:.2f}ms:", e)
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+# Add async wrapper for get_user_data
+async def get_user_data_async(uid: str):
+    start_time = time.time()
+    
+    # Try to get from cache first
+    cached_data = get_cached_user_data(uid)
+    if cached_data:
+        print(f"[TIMING] User data (cached): {(time.time() - start_time) :.2f}ms")
+        return cached_data
+    
+    # Cache miss - fetch fresh data
+    print("[CACHE] User data cache miss, fetching fresh data...")
+    result = get_user_data(uid)
+    print(f"[TIMING] User data fetch: {(time.time() - start_time) :.2f}ms")
+    return result
+
+
+@app.get("/cache/stats")
+async def cache_stats_endpoint():
+    """Get cache performance statistics"""
+    from backend.cache_utils import get_cache_stats, cleanup_expired_cache
+    cleanup_expired_cache()  # Clean up while we're at it
+    stats = get_cache_stats()
+    return stats
+
+@app.post("/cache/clear")
+async def clear_cache_endpoint(user_id: str = None):
+    """Clear cache for specific user or all users"""
+    from backend.cache_utils import clear_user_cache
+    clear_user_cache(user_id)
+    return {"message": f"Cache cleared for {'all users' if not user_id else f'user {user_id}'}"}
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 3000)) 
+    uvicorn.run(app, host="0.0.0.0", port=port)

tools/goal_tools.py

@@ -0,0 +1,138 @@
+from google.cloud import firestore
+from langchain_core.tools import tool
+from datetime import datetime, timedelta
+import pytz
+
+
+from backend.credentials import setup_google_credentials
+setup_google_credentials()
+
+APP_TO_DB_CATEGORY = {
+    "vocational": "occupational",
+}
+
+def to_db_category(slug):
+    return APP_TO_DB_CATEGORY.get(slug, slug)
+
+def add_goal_to_firestore(user_id, goal_name, goal_description, category_slug, 
+                         timeframe="Month", reminder_enabled=True, duration_weeks=6):
+    """
+    Add a goal to Firestore with proper timestamps and fields
+    
+    Args:
+        user_id: User's Firebase UID
+        goal_name: Name of the goal
+        goal_description: Description of the goal
+        category_slug: Wellness dimension (physical, mental, etc.)
+        timeframe: Goal timeframe (Month, Week, Year)
+        reminder_enabled: Whether to enable reminders
+        duration_weeks: How many weeks the goal should run
+    """
+    db = firestore.Client()
+    
+    # Map app slug to db slug
+    category_slug = to_db_category(category_slug)
+    
+    # Look up the category
+    cat_docs = db.collection("goals_categories").where("cat_slug", "==", category_slug).stream()
+    cat_doc = next(cat_docs, None)
+    if not cat_doc:
+        raise Exception(f"Category with slug '{category_slug}' not found.")
+    
+    cat_id = cat_doc.id
+    cat_data = cat_doc.to_dict()
+    
+    # Create timestamps
+    now = datetime.now(pytz.UTC)
+    end_date = now + timedelta(weeks=duration_weeks)
+    
+    goal_data = {
+        "endDate": end_date,
+        "goalDescription": goal_description,
+        "goalName": goal_name,
+        "goalReminder": reminder_enabled,
+        "startDate": now,
+        "status": True,
+        "timeFrame": timeframe,
+        "user_id": user_id,
+        "wellnessDimension": cat_id,
+        "wellnessDimension_ref": f"/goals_categories/{cat_id}",      
+    }
+    
+    # Add to Firestore
+    doc_ref = db.collection("goals").add(goal_data)
+    
+    # Return the data with the document ID
+    result = goal_data.copy()
+    result["id"] = doc_ref[1].id  # doc_ref is a tuple (timestamp, document_reference)
+    
+    return result
+
+@tool("add_goal")
+def add_goal_tool(user_id: str, goal_name: str, goal_description: str, category_slug: str, 
+                 timeframe: str = "Month", reminder_enabled: bool = True, duration_weeks: int = 6):
+    """
+    Add a new user goal to Firestore with category_slug (physical, mental, social, etc).
+    
+    Args:
+        user_id: User's Firebase UID
+        goal_name: Short name for the goal
+        goal_description: Detailed description of what the goal entails
+        category_slug: Wellness dimension slug (physical, mental, spiritual, etc.)
+        timeframe: Goal timeframe - "Month", "Week", or "Year" (default: "Month")
+        reminder_enabled: Whether to enable reminders (default: True)
+        duration_weeks: How many weeks the goal should run (default: 6)
+    """
+    try:
+        result = add_goal_to_firestore(
+            user_id, 
+            goal_name, 
+            goal_description, 
+            category_slug,
+            timeframe,
+            reminder_enabled,
+            duration_weeks
+        )
+        print("INSIDE TOOL RESULT:", result, type(result))
+        
+        from backend.cache_utils import clear_user_cache
+        clear_user_cache(user_id)
+        
+        if isinstance(result, dict):
+            # Convert datetime objects to strings for JSON serialization
+            serializable_result = {}
+            for key, value in result.items():
+                if isinstance(value, datetime):
+                    serializable_result[key] = value.isoformat()
+                else:
+                    serializable_result[key] = value
+            return serializable_result
+        elif hasattr(result, "dict"):
+            return result.dict()
+        else:
+            return {"error": "Unexpected result type", "result": str(result)}
+            
+    except Exception as e:
+        print(f"Error in add_goal_tool: {e}")
+        return {"error": str(e), "success": False}
+
+
+@tool("list_goal_categories")
+def list_goal_categories():
+    """List all available wellness dimension categories for goals."""
+    try:
+        db = firestore.Client()
+        categories = []
+        
+        for doc in db.collection("goals_categories").stream():
+            cat_data = doc.to_dict()
+            categories.append({
+                "id": doc.id,
+                "name": cat_data.get("cat_name", "Unknown"),
+                "slug": cat_data.get("cat_slug", "unknown"),
+                "description": cat_data.get("cat_description", "")
+            })
+        
+        return {"categories": categories}
+    except Exception as e:
+        return {"error": str(e), "categories": []}