Upload 2 files

app.py

@@ -0,0 +1,1034 @@
+import os
+import json
+import shutil
+import gradio as gr
+import tempfile
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+from pytube import YouTube
+from pathlib import Path
+import re
+import pandas as pd
+
+# --- Agent Imports ---
+try:
+    from alz_companion.agent import (
+        bootstrap_vectorstore, make_rag_chain, answer_query, synthesize_tts,
+        transcribe_audio, detect_tags_from_query, describe_image, build_or_load_vectorstore,
+        _default_embeddings, route_query_type, call_llm
+    )
+    from alz_companion.prompts import (
+        BEHAVIOUR_TAGS, EMOTION_STYLES, FAITHFULNESS_JUDGE_PROMPT
+    )
+    from langchain.schema import Document
+    from langchain_community.vectorstores import FAISS
+    AGENT_OK = True
+except Exception as e:
+    AGENT_OK = False
+    class Document:
+        def __init__(self, page_content, metadata): self.page_content, self.metadata = page_content, metadata
+    class FAISS:
+        def __init__(self):
+            self.docstore = type('obj', (object,), {'_dict': {}})()
+        def add_documents(self, docs):
+            start_idx = len(self.docstore._dict)
+            for i, d in enumerate(docs, start_idx):
+                self.docstore._dict[i] = d
+        def save_local(self, path): pass
+        @classmethod
+        def from_documents(cls, docs, embeddings=None):
+            inst = cls()
+            inst.add_documents(docs)
+            return inst
+    def build_or_load_vectorstore(docs, index_path, is_personal=False): return FAISS.from_documents(docs or [], embeddings=None)
+    def bootstrap_vectorstore(sample_paths=None, index_path="data/"): return object()
+    def make_rag_chain(vs_general, vs_personal, **kwargs): return lambda q, **k: {"answer": f"(Demo) You asked: {q}", "sources": []}
+    def answer_query(chain, q, **kwargs): return chain(q, **kwargs)
+    def synthesize_tts(text: str, lang: str = "en"): return None
+    def transcribe_audio(filepath: str, lang: str = "en"): return "This is a transcribed message."
+    def detect_tags_from_query(*args, **kwargs): return {"detected_behavior": "None", "detected_emotion": "None"}
+    def describe_image(image_path: str): return "This is a description of an image."
+    def _default_embeddings(): return None
+    def route_query_type(query: str): return "general_conversation"
+    def call_llm(messages, **kwargs): return "Cannot call LLM in fallback mode."
+    BEHAVIOUR_TAGS, EMOTION_STYLES, FAITHFULNESS_JUDGE_PROMPT = {"None": []}, {"None": {}}, ""
+    print(f"WARNING: Could not import from alz_companion ({e}). Running in UI-only demo mode.")
+    
+
+# --- NEW: Import for Evaluation Logic ---
+try:
+    from evaluate import load_test_fixtures, run_comprehensive_evaluation
+except ImportError:
+    # Fallback if evaluate.py is not found
+    def load_test_fixtures(): print("WARNING: evaluate.py not found.")
+    def run_comprehensive_evaluation(*args, **kwargs): return "Evaluation module not found.", []
+
+
+# --- Centralized Configuration ---
+CONFIG = {
+    "themes": ["All", "The Father", "Still Alice", "Away from Her", "Alive Inside", "General Caregiving"],
+    "roles": ["patient", "caregiver"],
+    "disease_stages": ["Default: Mild Stage",  "Moderate Stage", "Advanced Stage"],
+    "behavior_tags": ["None"] + list(BEHAVIOUR_TAGS.keys()),
+    "emotion_tags": ["None"] + list(EMOTION_STYLES.keys()),
+    "topic_tags": ["None", "caregiving_advice", "medical_fact", "personal_story", "research_update", "treatment_option:home_safety", "treatment_option:long_term_care", "treatment_option:music_therapy", "treatment_option:reassurance", "treatment_option:routine_structuring", "treatment_option:validation_therapy"],
+    "context_tags": ["None", "disease_stage_mild", "disease_stage_moderate", "disease_stage_advanced", "disease_stage_unspecified", "interaction_mode_one_to_one", "interaction_mode_small_group", "interaction_mode_group_activity", "relationship_family", "relationship_spouse", "relationship_staff_or_caregiver", "relationship_unspecified", "setting_home_or_community", "setting_care_home", "setting_clinic_or_hospital"],
+    "languages": {"English": "en", "Chinese": "zh", "Cantonese": "zh-yue", "Korean": "ko", "Japanese": "ja", "Malay": "ms", "French": "fr", "Spanish": "es", "Hindi": "hi", "Arabic": "ar"},
+    "tones": ["warm", "empathetic", "caring", "reassuring", "calm", "optimistic", "motivating", "neutral", "formal", "humorous"],
+    # --- ADD THIS NEW KEY AND LIST ---
+    "music_moods": [
+        "Confusion or Disorientation",
+        "Reminiscence and Connection",
+        "Sundowning or Restlessness",
+        "Sadness or Longing",
+        "Anxiety or Fear",
+        "Agitation or Anger",
+        "Joy or Affection"
+    ]
+    # --- END OF ADDITION ---
+}
+
+# --- File Management & Vector Store Logic ---
+def _storage_root() -> Path:
+    for p in [Path(os.getenv("SPACE_STORAGE", "")), Path("/data"), Path.home() / ".cache" / "alz_companion"]:
+        if not p: continue
+        try:
+            p.mkdir(parents=True, exist_ok=True)
+            (p / ".write_test").write_text("ok")
+            (p / ".write_test").unlink(missing_ok=True)
+            return p
+        except Exception: continue
+    tmp = Path(tempfile.gettempdir()) / "alz_companion"
+    tmp.mkdir(parents=True, exist_ok=True)
+    return tmp
+    
+STORAGE_ROOT = _storage_root()
+INDEX_BASE = STORAGE_ROOT / "index"
+# --- NEW: Define path for the auto-loading folder ---
+PERSISTENT_MEMORY_PATH = Path(__file__).parent / "Personal Memory Bank"
+# --- END NEW ---
+PERSONAL_DATA_BASE = STORAGE_ROOT / "personal"
+UPLOADS_BASE = INDEX_BASE / "uploads"
+PERSONAL_INDEX_PATH = str(PERSONAL_DATA_BASE / "personal_faiss_index")
+NLU_EXAMPLES_INDEX_PATH = str(INDEX_BASE / "nlu_examples_faiss_index")
+THEME_PATHS = {t: str(INDEX_BASE / f"faiss_index_{t.replace(' ', '').lower()}") for t in CONFIG["themes"]}
+os.makedirs(UPLOADS_BASE, exist_ok=True)
+os.makedirs(PERSONAL_DATA_BASE, exist_ok=True)
+# --- NEW: Create the folders on startup if it does not exist ---
+os.makedirs(PERSISTENT_MEMORY_PATH, exist_ok=True)
+# --- END NEW ---
+
+
+for p in THEME_PATHS.values(): os.makedirs(p, exist_ok=True)
+vectorstores = {}
+personal_vectorstore = None
+nlu_vectorstore = None
+
+try:
+    personal_vectorstore = build_or_load_vectorstore([], PERSONAL_INDEX_PATH, is_personal=True)
+except Exception:
+    personal_vectorstore = None
+def bootstrap_nlu_vectorstore(example_file: str, index_path: str) -> FAISS:
+    if not os.path.exists(example_file):
+        print(f"WARNING: NLU example file not found at {example_file}. NLU will be less accurate.")
+        return build_or_load_vectorstore([], index_path)
+    docs = []
+    with open(example_file, "r", encoding="utf-8") as f:
+        for line in f:
+            try:
+                data = json.loads(line)
+                doc = Document(page_content=data["query"], metadata=data)
+                docs.append(doc)
+            except (json.JSONDecodeError, KeyError): continue
+    print(f"Found and loaded {len(docs)} NLU training examples.")
+    if os.path.exists(index_path): shutil.rmtree(index_path)
+    return build_or_load_vectorstore(docs, index_path)
+
+
+# In app.py, near the other path definitions
+PERSONAL_MUSIC_BASE = PERSONAL_DATA_BASE / "music"
+os.makedirs(PERSONAL_MUSIC_BASE, exist_ok=True)
+
+# In app.py, replace your existing versions of these three functions with the code below.
+# --- Function 1: Auto-loads non-music memories from the 'Personal Memory Bank' folder ---
+def load_personal_files_from_folder():
+    """
+    Scans the 'Personal Memory Bank' folder and loads new multi-modal files 
+    (text, audio, video, images) into the personal vectorstore.
+    """
+    global personal_vectorstore
+    print("Scanning 'Personal Memory Bank' folder for new files...")
+    if not os.path.exists(PERSISTENT_MEMORY_PATH):
+        return
+
+    # Define supported file extensions
+    TEXT_EXTENSIONS = (".txt",)
+    AUDIO_EXTENSIONS = (".mp3", ".wav", ".m4a", ".flac")
+    VIDEO_EXTENSIONS = (".mp4", ".mov", ".avi", ".mkv")
+    IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".gif", ".bmp")
+
+    # Get a list of sources already in the vectorstore to avoid re-processing files
+    existing_sources = set()
+    if personal_vectorstore and hasattr(personal_vectorstore.docstore, '_dict'):
+        for doc in personal_vectorstore.docstore._dict.values():
+            existing_sources.add(doc.metadata.get("source"))
+
+    docs_to_add = []
+    for filename in os.listdir(PERSISTENT_MEMORY_PATH):
+        if filename in existing_sources:
+            continue
+
+        filepath = PERSISTENT_MEMORY_PATH / filename
+        content_to_process = ""
+        
+        file_lower = filename.lower()
+
+        if file_lower.endswith(TEXT_EXTENSIONS):
+            print(f"  - Found new text file to load: {filename}")
+            with open(filepath, "r", encoding="utf-8") as f:
+                content_to_process = f.read()
+        
+        elif file_lower.endswith(AUDIO_EXTENSIONS) or file_lower.endswith(VIDEO_EXTENSIONS):
+            media_type = "Audio" if file_lower.endswith(AUDIO_EXTENSIONS) else "Video"
+            print(f"  - Found new {media_type} file to transcribe: {filename}")
+            try:
+                transcribed_text = transcribe_audio(str(filepath))
+                title = os.path.splitext(filename)[0].replace('_', ' ').replace('-', ' ')
+                content_to_process = f"Title: {title}\n\nContent: {transcribed_text}"
+            except Exception as e:
+                print(f"    - ERROR: Failed to transcribe {filename}. Reason: {e}")
+                continue
+        
+        elif file_lower.endswith(IMAGE_EXTENSIONS):
+            print(f"  - Found new Image file to describe: {filename}")
+            try:
+                description = describe_image(str(filepath))
+                title = os.path.splitext(filename)[0].replace('_', ' ').replace('-', ' ')
+                content_to_process = f"Title: {title}\n\nContent: {description}"
+            except Exception as e:
+                print(f"    - ERROR: Failed to describe {filename}. Reason: {e}")
+                continue
+
+        if content_to_process:
+            docs_to_add.extend(parse_and_tag_entries(content_to_process, source=filename, settings={}))
+
+    if docs_to_add:
+        if personal_vectorstore is None:
+            personal_vectorstore = build_or_load_vectorstore(docs_to_add, PERSONAL_INDEX_PATH, is_personal=True)
+        else:
+            personal_vectorstore.add_documents(docs_to_add)
+        
+        personal_vectorstore.save_local(PERSONAL_INDEX_PATH)
+        print(f"Successfully added {len(docs_to_add)} new document(s) from the folder.")
+
+
+# --- Function 2: Auto-syncs music from the 'Music Library' folder (Hybrid Approach) ---
+def sync_music_library_from_folder():
+    """Scans 'Music Library' folder, syncs manifest for playback, and adds lyrics to vectorstore."""
+    global personal_vectorstore
+    music_library_path = PERSISTENT_MEMORY_PATH / "Music Library"
+    os.makedirs(music_library_path, exist_ok=True)
+    
+    manifest_path = PERSONAL_MUSIC_BASE / "music_manifest.json"
+    manifest = {}
+    if manifest_path.exists():
+        with open(manifest_path, "r") as f: manifest = json.load(f)
+    
+    existing_sources = set()
+    if personal_vectorstore and hasattr(personal_vectorstore.docstore, '_dict'):
+        for doc in personal_vectorstore.docstore._dict.values():
+            existing_sources.add(doc.metadata.get("source"))
+
+    print("Scanning 'Music Library' folder for new songs...")
+    filename_pattern = re.compile(r'^(.*?) - (.*?) - (.*?)\.(mp3|wav|m4a|ogg|flac)$', re.IGNORECASE)
+    
+    synced_count = 0
+    docs_to_add = []
+    for filename in os.listdir(music_library_path):
+        song_id = filename.replace(" ", "_").lower()
+        if song_id in manifest and filename in existing_sources:
+            continue
+
+        match = filename_pattern.match(filename)
+        if match:
+            print(f"  - Found new song to sync: {filename}")
+            title, artist, tag = match.groups()[:3]
+            
+            source_path = music_library_path / filename
+            dest_path = PERSONAL_MUSIC_BASE / filename
+            if not os.path.exists(dest_path):
+                shutil.copy2(str(source_path), str(dest_path))
+
+            # Add to manifest for playback system
+            song_metadata = {"title": title.strip(), "artist": artist.strip(), "moods": [tag.strip().lower()], "filepath": str(dest_path)}
+            manifest[song_id] = song_metadata
+            
+            # --- NEW HYBRID LOGIC: Transcribe and prep for vectorstore ---
+            # Transcribe and prep for semantic memory system (vectorstore)
+            if filename not in existing_sources:
+                try:
+                    print(f"    - Transcribing '{title}' for memory bank...")
+                    lyrics = transcribe_audio(str(dest_path))
+                    content_for_rag = (
+                        f"Title: Song - {song_metadata['title']}\n"
+                        f"Artist: {song_metadata['artist']}\n"
+                        f"Moods: {', '.join(song_metadata['moods'])}\n\n"
+                        f"Lyrics:\n{lyrics}"
+                    )
+                    docs_to_add.extend(parse_and_tag_entries(content_for_rag, source=filename, settings={}))
+                except Exception as e:
+                    print(f"    - WARNING: Failed to transcribe {filename} for memory bank. Error: {e}")
+            # --- END OF NEW HYBRID LOGIC ---
+            synced_count += 1
+
+    if synced_count > 0:
+        with open(manifest_path, "w") as f: json.dump(manifest, f, indent=2)
+        print(f"Successfully synced {synced_count} new song(s) to the music manifest.")
+    
+    if docs_to_add:
+        if personal_vectorstore is None:
+            personal_vectorstore = build_or_load_vectorstore(docs_to_add, PERSONAL_INDEX_PATH, is_personal=True)
+        else:
+            personal_vectorstore.add_documents(docs_to_add)
+        personal_vectorstore.save_local(PERSONAL_INDEX_PATH)
+        print(f"Successfully added lyrics for {len(docs_to_add)} song(s) to the personal vectorstore.")
+
+
+def canonical_theme(tk: str) -> str: return tk if tk in CONFIG["themes"] else "All"
+def theme_upload_dir(theme: str) -> str:
+    p = UPLOADS_BASE / f"theme_{canonical_theme(theme).replace(' ', '').lower()}"
+    p.mkdir(exist_ok=True)
+    return str(p)
+def load_manifest(theme: str) -> Dict[str, Any]:
+    p = os.path.join(theme_upload_dir(theme), "manifest.json")
+    if os.path.exists(p):
+        try:
+            with open(p, "r", encoding="utf-8") as f: return json.load(f)
+        except Exception: pass
+    return {"files": {}}
+def save_manifest(theme: str, man: Dict[str, Any]):
+    with open(os.path.join(theme_upload_dir(theme), "manifest.json"), "w", encoding="utf-8") as f: json.dump(man, f, indent=2)
+def list_theme_files(theme: str) -> List[tuple[str, bool]]:
+    man = load_manifest(theme)
+    base = theme_upload_dir(theme)
+    found = [(n, bool(e)) for n, e in man.get("files", {}).items() if os.path.exists(os.path.join(base, n))]
+    existing = {n for n, e in found}
+    for name in sorted(os.listdir(base)):
+        if name not in existing and os.path.isfile(os.path.join(base, name)): found.append((name, False))
+    man["files"] = dict(found)
+    save_manifest(theme, man)
+    return found
+def copy_into_theme(theme: str, src_path: str) -> str:
+    fname = os.path.basename(src_path)
+    dest = os.path.join(theme_upload_dir(theme), fname)
+    shutil.copy2(src_path, dest)
+    return dest
+def seed_files_into_theme(theme: str):
+    SEED_FILES = [("sample_data/caregiving_tips.txt", True), ("sample_data/the_father_segments_enriched_harmonized_plus.jsonl", True), ("sample_data/still_alice_enriched_harmonized_plus.jsonl", True), ("sample_data/away_from_her_enriched_harmonized_plus.jsonl", True), ("sample_data/alive_inside_enriched_harmonized.jsonl", True)]
+    man, changed = load_manifest(theme), False
+    for path, enable in SEED_FILES:
+        if not os.path.exists(path): continue
+        fname = os.path.basename(path)
+        if not os.path.exists(os.path.join(theme_upload_dir(theme), fname)):
+            copy_into_theme(theme, path)
+            man["files"][fname] = bool(enable)
+            changed = True
+    if changed: save_manifest(theme, man)
+def ensure_index(theme='All'):
+    theme = canonical_theme(theme)
+    if theme in vectorstores: return vectorstores[theme]
+    upload_dir = theme_upload_dir(theme)
+    enabled_files = [os.path.join(upload_dir, n) for n, enabled in list_theme_files(theme) if enabled]
+    index_path = THEME_PATHS.get(theme)
+    vectorstores[theme] = bootstrap_vectorstore(sample_paths=enabled_files, index_path=index_path)
+    return vectorstores[theme]
+
+# --- Gradio Callbacks ---
+# In app.py, modify the collect_settings function
+
+def collect_settings(*args):
+    keys = ["role", "patient_name", "caregiver_name", "tone", "language", "tts_lang", "temperature", 
+            # --- ADD "disease_stage" to this list ---
+            "disease_stage", 
+            "behaviour_tag", "emotion_tag", "topic_tag", "active_theme", "tts_on", "debug_mode"]
+    return dict(zip(keys, args))
+    
+
+# In app.py, replace the entire parse_and_tag_entries function.
+def parse_and_tag_entries(text_content: str, source: str, settings: dict = None) -> List[Document]:
+    docs_to_add = []
+    # This logic correctly handles both simple text and complex journal entries
+    entries = re.split(r'\n(?:---|--|-|-\*-|-\.-)\n', text_content)
+    if len(entries) == 1 and "title:" not in entries[0].lower() and "content:" not in entries[0].lower():
+        entries = [text_content] # Treat simple text as a single entry
+
+    for entry in entries:
+        if not entry.strip(): continue
+        
+        lines = entry.strip().split('\n')
+        title_line = lines[0].split(':', 1)
+        title = title_line[1].strip() if len(title_line) > 1 and "title:" in lines[0].lower() else "Untitled Text Entry"
+        content_part = "\n".join(lines[1:])
+        content = content_part.split(':', 1)[1].strip() if "content:" in content_part.lower() else content_part.strip() or entry.strip()
+
+        if not content: continue
+        
+        full_content = f"Title: {title}\n\nContent: {content}"
+        
+        detected_tags = detect_tags_from_query(
+            content, nlu_vectorstore=nlu_vectorstore, 
+            behavior_options=CONFIG["behavior_tags"], emotion_options=CONFIG["emotion_tags"],
+            topic_options=CONFIG["topic_tags"], context_options=CONFIG["context_tags"],
+            settings=settings
+        )
+        
+        metadata = {"source": source, "title": title}
+        
+        # --- START: CORRECTED METADATA ASSIGNMENT ---
+        if detected_tags.get("detected_behaviors"):
+            metadata["behaviors"] = [b.lower() for b in detected_tags["detected_behaviors"]]
+        detected_emotion = detected_tags.get("detected_emotion")
+        if detected_emotion and detected_emotion != "None":
+            metadata["emotion"] = detected_emotion.lower()
+        
+        # Correctly handle the plural "detected_topics" key and list value
+        detected_topics = detected_tags.get("detected_topics")
+        if detected_topics:
+            metadata["topic_tags"] = [t.lower() for t in detected_topics]
+            
+        if detected_tags.get("detected_contexts"):
+            metadata["context_tags"] = [c.lower() for c in detected_tags["detected_contexts"]]
+        # --- END: CORRECTED METADATA ASSIGNMENT ---
+        
+        docs_to_add.append(Document(page_content=full_content, metadata=metadata))
+
+    return docs_to_add
+
+
+def handle_add_knowledge(title, text_input, file_input, image_input, yt_url, settings):
+    global personal_vectorstore
+    docs_to_add = []
+    source, content = "Unknown", ""
+    if text_input and text_input.strip():
+        source, content = "Text Input", f"Title: {title or 'Untitled'}\n\nContent: {text_input}"
+    elif file_input:
+        source = os.path.basename(file_input.name)
+        if file_input.name.lower().endswith('.txt'):
+            with open(file_input.name, 'r', encoding='utf-8') as f: content = f.read()
+        else:
+            transcribed = transcribe_audio(file_input.name)
+            content = f"Title: {title or 'Audio/Video Note'}\n\nContent: {transcribed}"
+    elif image_input:
+        source, description = "Image Input", describe_image(image_input)
+        content = f"Title: {title or 'Image Note'}\n\nContent: {description}"
+    elif yt_url and ("youtube.com" in yt_url or "youtu.be" in yt_url):
+        try:
+            yt = YouTube(yt_url)
+            with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_audio_file:
+                yt.streams.get_audio_only().download(filename=temp_audio_file.name)
+                transcribed = transcribe_audio(temp_audio_file.name)
+                os.remove(temp_audio_file.name)
+            source, content = f"YouTube: {yt.title}", f"Title: {title or yt.title}\n\nContent: {transcribed}"
+        except Exception as e:
+            return f"Error processing YouTube link: {e}"
+    else:
+        return "Please provide content to add."
+    if content:
+        docs_to_add = parse_and_tag_entries(content, source, settings=settings)
+    if not docs_to_add: return "No processable content found to add."
+    if personal_vectorstore is None:
+        personal_vectorstore = build_or_load_vectorstore(docs_to_add, PERSONAL_INDEX_PATH, is_personal=True)
+    else:
+        personal_vectorstore.add_documents(docs_to_add)
+    personal_vectorstore.save_local(PERSONAL_INDEX_PATH)
+    return f"Successfully added {len(docs_to_add)} new memory/memories."
+
+
+# In app.py, add this new handler function
+
+def handle_add_music(file, title, artist, mood):
+    if not all([file, title, artist, mood]):
+        return "Please fill out all fields."
+    
+    # Save the audio file
+    filename = os.path.basename(file.name)
+    dest_path = PERSONAL_MUSIC_BASE / filename
+    shutil.copy2(file.name, str(dest_path))
+
+    # Save the metadata to a manifest file
+    manifest_path = PERSONAL_MUSIC_BASE / "music_manifest.json"
+    manifest = {}
+    if manifest_path.exists():
+        with open(manifest_path, "r") as f:
+            manifest = json.load(f)
+
+    song_id = filename.replace(" ", "_").lower()
+    manifest[song_id] = {
+        "title": title.strip(),
+        "artist": artist.strip(),
+        # "moods": [m.strip().lower() for m in mood.split(",")],
+        "moods": [m.lower() for m in mood], # Correctly handles the list from the dropdown
+        "filepath": str(dest_path) # Store the full path for backend access
+    }
+
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    return f"Successfully added '{title}' to the music library."
+
+# In app.py, add these two new functions (e.g., after the handle_add_music function)
+
+def list_music_library():
+    """Loads the music manifest and formats it for the Gradio UI."""
+    manifest_path = PERSONAL_MUSIC_BASE / "music_manifest.json"
+    if not manifest_path.exists():
+        return gr.update(value=[["Library is empty", "", ""]]), gr.update(choices=[], value=None)
+    
+    with open(manifest_path, "r") as f:
+        manifest = json.load(f)
+        
+    if not manifest:
+        return gr.update(value=[["Library is empty", "", ""]]), gr.update(choices=[], value=None)
+
+    display_data = [[data['title'], data['artist'], ", ".join(data['moods'])] for data in manifest.values()]
+    
+    # Use the song's unique ID (the key in the manifest) for the delete dropdown
+    delete_choices = list(manifest.keys())
+
+    return gr.update(value=display_data), gr.update(choices=delete_choices, value=None)
+
+def delete_music_from_library(song_id_to_delete):
+    """Deletes a song from the manifest, the audio file, and the vectorstore."""
+    global personal_vectorstore
+    if not song_id_to_delete:
+        return "No music selected to delete."
+
+    # 1. Remove from manifest and delete audio file
+    manifest_path = PERSONAL_MUSIC_BASE / "music_manifest.json"
+    if not manifest_path.exists(): return "Error: Music manifest not found."
+
+    with open(manifest_path, "r") as f: manifest = json.load(f)
+    
+    song_to_delete = manifest.pop(song_id_to_delete, None)
+    if not song_to_delete: return f"Error: Could not find song ID {song_id_to_delete} in manifest."
+    
+    with open(manifest_path, "w") as f: json.dump(manifest, f, indent=2)
+
+    try:
+        os.remove(song_to_delete['filepath'])
+    except OSError as e:
+        print(f"Error deleting audio file {song_to_delete['filepath']}: {e}")
+
+    # 2. Remove lyrics from the personal vectorstore
+    if personal_vectorstore and hasattr(personal_vectorstore.docstore, '_dict'):
+        filename_to_delete = os.path.basename(song_to_delete['filepath'])
+        all_docs = list(personal_vectorstore.docstore._dict.values())
+        
+        # Find the document whose source matches the audio filename
+        docs_to_keep = [d for d in all_docs if d.metadata.get("source") != filename_to_delete]
+        
+        if len(all_docs) > len(docs_to_keep):
+            if not docs_to_keep: # If it was the last doc
+                if os.path.isdir(PERSONAL_INDEX_PATH): shutil.rmtree(PERSONAL_INDEX_PATH)
+                personal_vectorstore = build_or_load_vectorstore([], PERSONAL_INDEX_PATH, is_personal=True)
+            else:
+                new_vs = FAISS.from_documents(docs_to_keep, _default_embeddings())
+                new_vs.save_local(PERSONAL_INDEX_PATH)
+                personal_vectorstore = new_vs
+            return f"Successfully deleted '{song_to_delete['title']}' from the library and memory bank."
+
+    return f"Successfully deleted '{song_to_delete['title']}' from the music library."
+    
+
+def chat_fn(user_text, audio_file, settings, chat_history):
+
+    # --- ADD THIS DEBUG BLOCK AT THE TOP ---
+    print("\n" + "="*50)
+    print(f"[DEBUG app.py] chat_fn received settings: {settings}")
+    print("="*50 + "\n")
+    # --- END OF ADDITION ---
+    
+    global personal_vectorstore
+    question = (user_text or "").strip()
+    if audio_file and not question:
+        try:
+            question = transcribe_audio(audio_file, lang=CONFIG["languages"].get(settings.get("tts_lang", "English"), "en"))
+        except Exception as e:
+            err_msg = f"Audio Error: {e}" if settings.get("debug_mode") else "Sorry, I couldn't understand the audio."
+            chat_history.append({"role": "assistant", "content": err_msg})
+            return "", None, chat_history
+            
+    if not question:
+        return "", None, chat_history
+
+    # --- START FIX 1: Correctly process the incoming chat_history (list of dicts) ---
+    # The incoming chat_history is already in the desired format for the API,
+    # we just need to filter out our special system messages (like sources).
+    api_chat_history = [
+        msg for msg in chat_history
+        if msg.get("content") and not msg["content"].strip().startswith("*(")
+    ]
+    
+    # Append the new user question to the history that will be displayed in the UI
+    chat_history.append({"role": "user", "content": question})
+    # --- END FIX 1 ---
+
+    # NEW
+    query_type = route_query_type(question, severity=settings.get("disease_stage", "Default: Mild Stage"))
+    # query_type = route_query_type(question)
+    # --- ADD THIS DEBUG PRINT ---
+    print(f"[DEBUG] Router classified query as: {query_type}")
+    # --- END OF ADDITION ---
+
+    
+    final_tags = { "scenario_tag": None, "emotion_tag": None, "topic_tag": None, "context_tags": [] }
+    manual_behavior = settings.get("behaviour_tag", "None")
+    manual_emotion = settings.get("emotion_tag", "None")
+    manual_topic = settings.get("topic_tag", "None")
+
+    auto_detected_context = ""
+    if not all(m == "None" for m in [manual_behavior, manual_emotion, manual_topic]):
+        # --- ADD THIS DEBUG PRINT ---
+        print(f"[DEBUG app.py] Manual override DETECTED. Behavior='{manual_behavior}', Emotion='{manual_emotion}', Topic='{manual_topic}'")
+        # --- END OF ADDITION ---
+       
+        final_tags["scenario_tag"] = manual_behavior if manual_behavior != "None" else None
+        final_tags["emotion_tag"] = manual_emotion if manual_emotion != "None" else None
+        final_tags["topic_tag"] = manual_topic if manual_topic != "None" else None
+        
+    # NEW: Expand detecting emotions and behaviors for caregiving to music playing
+    # whenever a request to play music, the system will first analyze their query to detect an underlying emotion or behavior
+    elif "caregiving_scenario" in query_type or "play_music_request" in query_type:
+
+        # --- NEW DEBUG BLOCK: Print inputs before calling NLU ---
+        print("\n--- [DEBUG app.py] Preparing to call NLU ---")
+        print(f"  - Query to Analyze: '{question}'")
+        print(f"  - NLU Vectorstore Loaded: {nlu_vectorstore is not None}")
+        print(f"  - Current Settings Passed: {settings}")
+        print("------------------------------------------")
+        # --- END OF NEW DEBUG BLOCK ---
+        
+        detected_tags = detect_tags_from_query(
+            question, nlu_vectorstore=nlu_vectorstore, behavior_options=CONFIG["behavior_tags"],
+            emotion_options=CONFIG["emotion_tags"], topic_options=CONFIG["topic_tags"],
+            context_options=CONFIG["context_tags"], settings=settings)
+
+        # --- ADD THIS DEBUG PRINT ---
+        print(f"[DEBUG app.py] Raw NLU output: {detected_tags}")
+        # --- END OF ADDITION ---
+        
+        behaviors = detected_tags.get("detected_behaviors")
+        final_tags["scenario_tag"] = behaviors[0] if behaviors else None
+        final_tags["emotion_tag"] = detected_tags.get("detected_emotion")
+        final_tags["topic_tag"] = detected_tags.get("detected_topic")
+        final_tags["context_tags"] = detected_tags.get("detected_contexts", [])
+
+        # --- ADD THIS DEBUG PRINT ---
+        print(f"[DEBUG] NLU detected tags: {final_tags}")
+        # --- END OF ADDITION ---
+        
+        detected_parts = [f"{k.split('_')[1]}=`{v}`" for k, v in final_tags.items() if v and v != "None" and v != []]
+        if detected_parts:
+            auto_detected_context = f"*(Auto-detected context: {', '.join(detected_parts)})*"
+            
+    vs_general = ensure_index(settings.get("active_theme", "All"))
+    if personal_vectorstore is None:
+        personal_vectorstore = build_or_load_vectorstore([], PERSONAL_INDEX_PATH, is_personal=True)
+        
+    # OLD rag_settings = {k: settings.get(k) for k in ["role", "temperature", "language", "patient_name", "caregiver_name", "tone"]}
+    # NEW add "disease_stage"
+    # rag_settings = {k: settings.get(k) for k in ["role", "temperature", "language", "patient_name", "caregiver_name", "tone", "disease_stage"]}
+
+    # First, construct the path to the manifest file.
+    manifest_path_str = str(PERSONAL_MUSIC_BASE / "music_manifest.json")
+
+    # Then, gather all the settings from the UI into the dictionary.
+    rag_settings = {k: settings.get(k) for k in ["role", "temperature", "language", "patient_name", "caregiver_name", "tone", "disease_stage"]}
+
+    # Finally, add the special manifest path to that same dictionary.
+    rag_settings["music_manifest_path"] = manifest_path_str 
+    
+    chain = make_rag_chain(vs_general, personal_vectorstore, **rag_settings)
+    
+    response = answer_query(chain, question, query_type=query_type, chat_history=api_chat_history, **final_tags)
+
+   # --- MUSIC PLAYBACK LOGIC START ---
+
+    # 1. Extract the text answer and the potential music file path from the agent's response.
+    answer = response.get("answer", "[No answer found]")
+    audio_playback_url = response.get("audio_playback_url")
+
+    # 2. Append the text part of the response to the chat history so the user sees it.
+    chat_history.append({"role": "assistant", "content": answer})
+
+    if auto_detected_context:
+        chat_history.append({"role": "assistant", "content": auto_detected_context})
+    if response.get("sources"):
+        chat_history.append({"role": "assistant", "content": f"*(Sources used: {', '.join(response['sources'])})*"})
+
+    # 3. Decide what to play in the audio component: music takes priority over TTS.
+    audio_out_update = None
+    if audio_playback_url:
+        # If a music URL was returned, update the audio component to play that music file.
+        song_title = os.path.basename(audio_playback_url)
+        audio_out_update = gr.update(value=audio_playback_url, visible=True, label=f"Now Playing: {song_title}", autoplay=True)
+    elif settings.get("tts_on") and answer:
+        # Otherwise, if no music is playing and TTS is on, fall back to reading the text answer aloud.
+        tts_file = synthesize_tts(answer, lang=CONFIG["languages"].get(settings.get("tts_lang"), "en"))
+        audio_out_update = gr.update(value=tts_file, visible=bool(tts_file), label="Response Audio", autoplay=True)
+    
+    # 4. Return all the updates for the Gradio UI.
+    return "", audio_out_update, chat_history
+    
+    # --- MUSIC PLAYBACK LOGIC END ---
+
+ 
+# The save_chat_to_memory function incorrectly assumes the history is 
+# a list of tuples, like [(True, "..."), (False, "...")]
+# However, The chat_fn function correctly builds the chat_history as 
+# a list of dictionaries, like this:
+# [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
+# To correctly parse the list of dictionaries.
+def save_chat_to_memory(chat_history):
+    if not chat_history:
+        return "Nothing to save."
+
+    # --- START: MODIFIED LOGIC ---
+    # Correctly processes the list of dictionaries from the chatbot
+    formatted_chat = [
+        f"{msg.get('role', 'assistant').capitalize()}: {msg.get('content', '').strip()}"
+        for msg in chat_history
+        if isinstance(msg, dict) and msg.get('content') and not msg.get('content', '').strip().startswith("*(")
+    ]
+    # --- END: MODIFIED LOGIC ---
+
+    if not formatted_chat:
+        return "No conversation to save."
+
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    title = f"Conversation from {timestamp}"
+    full_content = f"Title: {title}\n\nContent:\n" + "\n".join(formatted_chat)
+    doc = Document(page_content=full_content, metadata={"source": "Saved Chat", "title": title})
+
+    global personal_vectorstore
+    if personal_vectorstore is None:
+        personal_vectorstore = build_or_load_vectorstore([doc], PERSONAL_INDEX_PATH, is_personal=True)
+    else:
+        personal_vectorstore.add_documents([doc])
+    
+    personal_vectorstore.save_local(PERSONAL_INDEX_PATH)
+    return f"Conversation from {timestamp} saved."
+
+
+def list_personal_memories():
+    global personal_vectorstore
+    if personal_vectorstore is None or not hasattr(personal_vectorstore.docstore, '_dict') or not personal_vectorstore.docstore._dict:
+        return gr.update(value=[["No memories", "", ""]]), gr.update(choices=[], value=None)
+    docs = list(personal_vectorstore.docstore._dict.values())
+    return gr.update(value=[[d.metadata.get('title', '...'), d.metadata.get('source', '...'), d.page_content] for d in docs]), gr.update(choices=[d.page_content for d in docs])
+def delete_personal_memory(memory_to_delete):
+    global personal_vectorstore
+    if personal_vectorstore is None or not memory_to_delete: return "No memory selected."
+    all_docs = list(personal_vectorstore.docstore._dict.values())
+    docs_to_keep = [d for d in all_docs if d.page_content != memory_to_delete]
+    if len(all_docs) == len(docs_to_keep): return "Error: Could not find memory."
+    if not docs_to_keep:
+        if os.path.isdir(PERSONAL_INDEX_PATH): shutil.rmtree(PERSONAL_INDEX_PATH)
+        personal_vectorstore = build_or_load_vectorstore([], PERSONAL_INDEX_PATH, is_personal=True)
+    else:
+        new_vs = FAISS.from_documents(docs_to_keep, _default_embeddings())
+        new_vs.save_local(PERSONAL_INDEX_PATH)
+        personal_vectorstore = new_vs
+    return "Successfully deleted memory."
+
+# --- EVALUATION FUNCTIONS: move them into evaluate.py
+# def evaluate_nlu_tags(expected: Dict[str, Any], actual: Dict[str, Any], tag_key: str, expected_key_override: str = None) -> Dict[str, float]:
+# def _parse_judge_json(raw_str: str) -> dict | None:
+# def run_comprehensive_evaluation():
+
+def upload_knowledge(files, theme):
+    for f in files: copy_into_theme(theme, f.name)
+    if theme in vectorstores: del vectorstores[theme]
+    return f"Uploaded {len(files)} file(s)."
+def save_file_selection(theme, enabled):
+    man = load_manifest(theme)
+    for fname in man['files']: man['files'][fname] = fname in enabled
+    save_manifest(theme, man)
+    if theme in vectorstores: del vectorstores[theme]
+    return f"Settings saved for theme '{theme}'."
+def refresh_file_list_ui(theme):
+    files = list_theme_files(theme)
+    return gr.update(choices=[f for f, _ in files], value=[f for f, en in files if en]), f"Found {len(files)} file(s)."
+def auto_setup_on_load(theme):
+    if not os.listdir(theme_upload_dir(theme)): seed_files_into_theme(theme)
+    # Changed the 11th argument from "All" to "None"
+    settings = collect_settings("patient", "", "", "warm", "English", "English", 0.7, 
+                                "None", "None", "None", "None", True, False)
+    files_ui, status = refresh_file_list_ui(theme)
+    return settings, files_ui, status
+    
+def test_save_file():
+    try:
+        path = PERSONAL_DATA_BASE / "persistence_test.txt"
+        path.write_text(f"File saved at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        return f"✅ Success! Wrote test file to: {path}"
+    except Exception as e: return f"❌ Error! Failed to write file: {e}"
+def check_test_file():
+    path = PERSONAL_DATA_BASE / "persistence_test.txt"
+    if path.exists(): return f"✅ Success! Found test file. Contents: '{path.read_text()}'"
+    return f"❌ Failure. Test file not found at: {path}"
+
+# --- UI Definition ---
+CSS = """
+.gradio-container { font-size: 14px; } 
+#chatbot { min-height: 400px; } 
+#audio_in audio, #audio_out audio { max-height: 40px; } 
+#audio_in .waveform, #audio_out .waveform { display: none !important; }
+#audio_in, #audio_out { min-height: 0px !important; }
+"""
+
+# OLD: add allowed_paths so the UI can access the music files
+# with gr.Blocks(theme=gr.themes.Soft(), css=CSS, allowed_paths=[str(PERSONAL_MUSIC_BASE)]) as demo:
+with gr.Blocks(theme=gr.themes.Soft(), css=CSS) as demo:
+    settings_state = gr.State({})
+    with gr.Tab("Chat"):
+        with gr.Row():
+            user_text = gr.Textbox(show_label=False, placeholder="Type your message here...", scale=7)
+            submit_btn = gr.Button("Send", variant="primary", scale=1)
+        with gr.Row():
+            audio_in = gr.Audio(sources=["microphone"], type="filepath", label="Voice Input", elem_id="audio_in")
+            audio_out = gr.Audio(label="Response Audio", autoplay=True, visible=True, elem_id="audio_out")
+        
+        chatbot = gr.Chatbot(elem_id="chatbot", label="Conversation", type="messages")
+        chat_status = gr.Markdown()
+        with gr.Row():
+            clear_btn = gr.Button("Clear")
+            save_btn = gr.Button("Save to Memory")
+
+    with gr.Tab("Personalize"):
+        gr.Markdown("### **Upload Personal Memory**")
+        with gr.Accordion("Add Multimodal Data to Personal Memory Bank", open=True):
+            personal_title = gr.Textbox(label="Title")
+            personal_text = gr.Textbox(lines=5, label="Text Content")
+            with gr.Row():
+                personal_file = gr.File(label="Upload Audio/Video/Text File")
+                personal_image = gr.Image(type="filepath", label="Upload Image")
+            personal_yt_url = gr.Textbox(label="Or, provide a YouTube URL")
+            personal_add_btn = gr.Button("Add Knowledge", variant="primary")
+            personal_status = gr.Markdown()
+            
+        # In app.py, within the "Personalize" Tab
+        gr.Markdown("### **Upload Personal Music Library**")
+        with gr.Accordion("Add Music to Personal Memory Bank", open=False):
+            music_file = gr.File(label="Upload Audio File (.mp3, .wav)", file_types=["audio"])
+            music_title = gr.Textbox(label="Song Title (e.g., My Way)")
+            music_artist = gr.Textbox(label="Artist (e.g., Frank Sinatra)")
+            # music_mood = gr.Textbox(label="Mood Tags (comma-separated, e.g., calm, happy, nostalgic)")
+            # NEW:  Add a dropdown menu music tag selection based on emotion and behavior tags
+            music_mood = gr.Dropdown(
+                CONFIG["music_moods"],
+                label="Select Moods/Contexts for this Song",
+                multiselect=True
+            )
+            music_add_btn = gr.Button("Add Music", variant="primary")
+            music_status = gr.Markdown()
+        
+        gr.Markdown("### **Manage Personal Memory Bank**")
+        with gr.Accordion("View/Hide Details", open=False):
+            personal_memory_display = gr.DataFrame(headers=["Title", "Source", "Content"], label="Saved Memories", row_count=(5, "dynamic"))
+            personal_refresh_btn = gr.Button("Refresh Memories")
+            personal_delete_selector = gr.Dropdown(label="Select memory to delete", scale=3, interactive=True)
+            personal_delete_btn = gr.Button("Delete Selected", variant="stop", scale=1)
+            personal_delete_status = gr.Markdown()
+
+        # --- NEW UI FOR MUSIC MANAGEMENT ---
+        gr.Markdown("### **Manage Music Library**")
+        with gr.Accordion("View/Hide Music Details", open=False):
+            music_library_display = gr.DataFrame(
+                headers=["Title", "Artist", "Moods"], 
+                label="Music Library", 
+                row_count=(5, "dynamic")
+            )
+            music_refresh_btn = gr.Button("Refresh Music List")
+            music_delete_selector = gr.Dropdown(
+                label="Select music to delete", 
+                scale=3, 
+                interactive=True
+            )
+            music_delete_btn = gr.Button("Delete Selected Music", variant="stop", scale=1)
+            music_delete_status = gr.Markdown()
+        # --- END OF NEW UI ---
+
+    with gr.Tab("Settings"):
+        with gr.Group():
+            gr.Markdown("## Conversation & Persona Settings")
+            with gr.Row():
+                role = gr.Radio(CONFIG["roles"], value="patient", label="Your Role")
+                patient_name = gr.Textbox(label="Patient's Name")
+                caregiver_name = gr.Textbox(label="Caregiver's Name")
+            with gr.Row():
+                temperature = gr.Slider(0.0, 1.2, value=0.7, step=0.1, label="Creativity")
+                tone = gr.Dropdown(CONFIG["tones"], value="warm", label="Response Tone")
+            with gr.Row():
+                # --- ADD THIS NEW DROPDOWN ---
+                # disease_stage = gr.Dropdown(CONFIG["disease_stages"], value="Normal / Unspecified", label="Assumed Disease Stage")
+                disease_stage = gr.Dropdown(CONFIG["disease_stages"], value="Default: Mild Stage", label="Assumed Disease Stage")
+                # --- END OF ADDITION ---
+                behaviour_tag = gr.Dropdown(CONFIG["behavior_tags"], value="None", label="Behaviour Filter (Manual)")
+                emotion_tag = gr.Dropdown(CONFIG["emotion_tags"], value="None", label="Emotion Filter (Manual)")
+                topic_tag = gr.Dropdown(CONFIG["topic_tags"], value="None", label="Topic Tag Filter (Manual)")
+        with gr.Accordion("Language, Voice & Debugging", open=False):
+            language = gr.Dropdown(list(CONFIG["languages"].keys()), value="English", label="Response Language")
+            tts_lang = gr.Dropdown(list(CONFIG["languages"].keys()), value="English", label="Voice Language")
+            tts_on = gr.Checkbox(True, label="Enable Voice Response")
+            debug_mode = gr.Checkbox(False, label="Show Debug Info")
+        gr.Markdown("--- \n ## General Knowledge Base Management")
+        with gr.Row():
+            with gr.Column(scale=1):
+                files_in = gr.File(file_count="multiple", file_types=[".jsonl", ".txt"], label="Upload Knowledge Files")
+                upload_btn = gr.Button("Upload to Theme")
+                seed_btn = gr.Button("Import Sample Data")
+                mgmt_status = gr.Markdown()
+            with gr.Column(scale=2):
+                active_theme = gr.Radio(CONFIG["themes"], value="All", label="Active Knowledge Theme")
+                files_box = gr.CheckboxGroup(choices=[], label="Enable Files for Selected Theme")
+                with gr.Row():
+                    save_files_btn = gr.Button("Save Selection", variant="primary")
+                    refresh_btn = gr.Button("Refresh List")
+        with gr.Accordion("Persistence Test", open=False):
+            test_save_btn = gr.Button("1. Run Persistence Test (Save File)")
+            check_save_btn = gr.Button("3. Check for Test File")
+            test_status = gr.Markdown()
+  
+    # --- UPDATED TESTING TAB ---
+    with gr.Tab("Testing"):
+        gr.Markdown("## Comprehensive Performance Evaluation")
+        gr.Markdown("Click the button below to run a full evaluation on all test fixtures. This will test NLU (Routing & Tagging) and generate RAG responses for manual review.")
+        
+        run_comprehensive_btn = gr.Button("Run Comprehensive Evaluation", variant="primary")
+        
+        batch_summary_md = gr.Markdown("### Evaluation Summary: Not yet run.")
+        
+        comprehensive_results_df = gr.DataFrame(
+            label="Detailed Evaluation Results", 
+            elem_id="comprehensive_results_df",
+            headers=[
+                "Test ID","Title","Route Correct?","Expected Route","Actual Route",
+                "Behavior F1","Emotion F1","Topic F1","Context F1",
+                "Generated Answer","Sources","Source Count","Latency (ms)", "Faithfulness"
+            ],
+            interactive=False
+        )
+        
+
+    # --- Event Wiring ---
+    all_settings = [
+        # Chat Tab Settings
+        role, patient_name, caregiver_name, tone, language, tts_lang, temperature,
+        # Disease Stage & Manual Filters
+        disease_stage, behaviour_tag, emotion_tag, topic_tag,
+        # Knowledge Base & Debug
+        active_theme, tts_on, debug_mode
+    ]
+    settings_state = gr.State({})
+
+    # In app.py, replace the event wiring loop right after the all_settings list
+
+    for component in all_settings:
+        component.change(fn=collect_settings, inputs=all_settings, outputs=settings_state)
+
+    submit_btn.click(fn=chat_fn, inputs=[user_text, audio_in, settings_state, chatbot], outputs=[user_text, audio_out, chatbot])
+    
+    # for c in all_settings: c.change(fn=collect_settings, inputs=all_settings, outputs=settings_state)
+    # submit_btn.click(fn=chat_fn, inputs=[user_text, audio_in, settings_state, chatbot], outputs=[user_text, audio_out, chatbot])
+    
+    save_btn.click(fn=save_chat_to_memory, inputs=[chatbot], outputs=[chat_status])
+    clear_btn.click(lambda: (None, None, [], None, "", ""), outputs=[user_text, audio_out, chatbot, audio_in, user_text, chat_status])
+    
+    personal_add_btn.click(fn=handle_add_knowledge, inputs=[personal_title, personal_text, personal_file, personal_image, personal_yt_url, settings_state], outputs=[personal_status]).then(lambda: (None, None, None, None, None), outputs=[personal_title, personal_text, personal_file, personal_image, personal_yt_url])
+    # Wire the button to the function in the UI event wiring section
+    music_add_btn.click(
+        fn=handle_add_music,
+        inputs=[music_file, music_title, music_artist, music_mood],
+        outputs=[music_status]
+    )
+     # --- NEW EVENT WIRING FOR MUSIC MANAGEMENT ---
+    music_refresh_btn.click(
+        fn=list_music_library, 
+        inputs=None, 
+        outputs=[music_library_display, music_delete_selector]
+    )
+    music_delete_btn.click(
+        fn=delete_music_from_library, 
+        inputs=[music_delete_selector], 
+        outputs=[music_delete_status]
+    ).then(
+        fn=list_music_library, 
+        inputs=None, 
+        outputs=[music_library_display, music_delete_selector]
+    )
+    # --- END OF NEW WIRING ---
+    
+    personal_refresh_btn.click(fn=list_personal_memories, inputs=None, outputs=[personal_memory_display, personal_delete_selector])
+    personal_delete_btn.click(fn=delete_personal_memory, inputs=[personal_delete_selector], outputs=[personal_delete_status]).then(fn=list_personal_memories, inputs=None, outputs=[personal_memory_display, personal_delete_selector])
+    
+    upload_btn.click(upload_knowledge, inputs=[files_in, active_theme], outputs=[mgmt_status]).then(refresh_file_list_ui, inputs=[active_theme], outputs=[files_box, mgmt_status])
+    save_files_btn.click(save_file_selection, inputs=[active_theme, files_box], outputs=[mgmt_status])
+    seed_btn.click(seed_files_into_theme, inputs=[active_theme]).then(refresh_file_list_ui, inputs=[active_theme], outputs=[files_box, mgmt_status])
+    refresh_btn.click(refresh_file_list_ui, inputs=[active_theme], outputs=[files_box, mgmt_status])
+    active_theme.change(refresh_file_list_ui, inputs=[active_theme], outputs=[files_box, mgmt_status])
+
+    # Then update the .click() event handler
+    run_comprehensive_btn.click(
+    fn=lambda: run_comprehensive_evaluation(
+        vs_general=ensure_index("All"),
+        vs_personal=personal_vectorstore, # <-- This is correctly passed in
+        nlu_vectorstore=nlu_vectorstore,
+        config=CONFIG,
+        storage_path=STORAGE_ROOT  # <-- ADD THIS ARGUMENT
+    ),
+    outputs=[batch_summary_md, comprehensive_results_df, comprehensive_results_df]
+)
+        
+    demo.load(auto_setup_on_load, inputs=[active_theme], outputs=[settings_state, files_box, mgmt_status])
+    demo.load(load_test_fixtures)
+    test_save_btn.click(fn=test_save_file, inputs=None, outputs=[test_status])
+    check_save_btn.click(fn=check_test_file, inputs=None, outputs=[test_status])
+
+# --- Startup Logic ---
+# --- Function 3: The Startup Orchestrator ---
+def pre_load_indexes():
+    """Loads all data sources and runs the auto-loading functions at startup."""
+    global personal_vectorstore, nlu_vectorstore
+    print("Pre-loading all indexes at startup...")
+    print("  - Loading NLU examples index...")
+    nlu_vectorstore = bootstrap_nlu_vectorstore("nlu_training_examples.jsonl", NLU_EXAMPLES_INDEX_PATH)
+    print(f"    ...NLU index loaded.")
+    for theme in CONFIG["themes"]:
+        print(f"  - Loading general index for theme: '{theme}'")
+        try:
+            ensure_index(theme)
+            print(f"    ...'{theme}' theme loaded.")
+        except Exception as e:
+            print(f"    ...Error loading theme '{theme}': {e}")
+            
+    print("  - Loading personal knowledge index...")
+    try:
+        personal_vectorstore = build_or_load_vectorstore([], PERSONAL_INDEX_PATH, is_personal=True)
+        print("    ...Personal knowledge loaded.")
+    except Exception as e:
+        print(f"    ...Error loading personal knowledge: {e}")
+        
+    # NEW: auto-loading and syncing functions with a small pre-loaded Personal Memory Bank 
+    load_personal_files_from_folder()
+    sync_music_library_from_folder()
+    
+    print("All indexes and personal files loaded. Application is ready.")
+
+
+
+if __name__ == "__main__":
+    seed_files_into_theme('All')
+    pre_load_indexes()
+    demo.queue().launch(debug=True, allowed_paths=[str(PERSONAL_MUSIC_BASE)])
+    # demo.queue().launch(debug=True)

evaluate.py

@@ -0,0 +1,405 @@
+# evaluate.py
+
+import os
+import json
+import time
+import re  # <-- ADD THIS IMPORT
+import pandas as pd
+from typing import List, Dict, Any
+from pathlib import Path
+
+# --- Imports from the main application ---
+# In evaluate.py
+
+try:
+    from alz_companion.agent import (
+        make_rag_chain, route_query_type, detect_tags_from_query,
+        answer_query, call_llm, build_or_load_vectorstore
+    )
+    from alz_companion.prompts import FAITHFULNESS_JUDGE_PROMPT
+    from langchain_community.vectorstores import FAISS
+    # --- Also move this import inside the try block for consistency ---
+    from langchain.schema import Document
+
+except ImportError:
+    # --- START: FALLBACK DEFINITIONS ---
+    class FAISS:
+        def __init__(self): self.docstore = type('obj', (object,), {'_dict': {}})()
+        def add_documents(self, docs): pass
+        def save_local(self, path): pass
+        @classmethod
+        def from_documents(cls, docs, embeddings=None): return cls()
+
+    class Document:
+        def __init__(self, page_content, metadata=None):
+            self.page_content = page_content
+            self.metadata = metadata or {}
+
+    def make_rag_chain(*args, **kwargs): return lambda q, **k: {"answer": f"(Eval Fallback) You asked: {q}", "sources": []}
+    def route_query_type(q, **kwargs): return "general_conversation"
+    def detect_tags_from_query(*args, **kwargs): return {}
+    def answer_query(chain, q, **kwargs): return chain(q, **kwargs)
+    def call_llm(*args, **kwargs): return "{}"
+    
+    # --- ADD FALLBACK DEFINITION FOR THE MISSING FUNCTION ---
+    def build_or_load_vectorstore(docs, index_path, is_personal=False):
+        return FAISS()
+    # --- END OF ADDITION ---
+
+    FAITHFULNESS_JUDGE_PROMPT = ""
+    print("WARNING: Could not import from alz_companion. Evaluation functions will use fallbacks.")
+    # --- END: FALLBACK DEFINITIONS ---
+    
+
+# --- LLM-as-a-Judge Prompt for Answer Correctness ---
+ANSWER_CORRECTNESS_JUDGE_PROMPT = """You are an expert evaluator. Your task is to assess the factual correctness of a generated answer against a ground truth answer.
+
+- GROUND_TRUTH_ANSWER: This is the gold-standard, correct answer.
+- GENERATED_ANSWER: This is the answer produced by the AI model.
+
+Evaluate if the GENERATED_ANSWER is factually aligned with the GROUND_TRUTH_ANSWER. Ignore minor differences in phrasing, tone, or structure. The key is factual accuracy.
+
+Respond with a single JSON object containing a float score from 0.0 to 1.0.
+- 1.0: The generated answer is factually correct and aligns perfectly with the ground truth.
+- 0.5: The generated answer is partially correct but misses key information or contains minor inaccuracies.
+- 0.0: The generated answer is factually incorrect or contradicts the ground truth.
+
+--- DATA TO EVALUATE ---
+GROUND_TRUTH_ANSWER:
+{ground_truth_answer}
+
+GENERATED_ANSWER:
+{generated_answer}
+---
+
+Return a single JSON object with your score:
+{{
+  "correctness_score": <float>
+}}
+"""
+
+test_fixtures = []
+
+def load_test_fixtures():
+    """Loads fixtures into the test_fixtures list."""
+    global test_fixtures
+    test_fixtures = []
+    env_path = os.environ.get("TEST_FIXTURES_PATH", "").strip()
+    candidates = [env_path] if env_path else ["conversation_test_fixtures_v10.jsonl", "conversation_test_fixtures_v8.jsonl"]
+    path = next((p for p in candidates if p and os.path.exists(p)), None)
+    if not path:
+        print("Warning: No test fixtures file found for evaluation.")
+        return
+    
+    # Use the corrected v10 file if available
+    if "conversation_test_fixtures_v10.jsonl" in path:
+        print(f"Using corrected test fixtures: {path}")
+
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            try:
+                test_fixtures.append(json.loads(line))
+            except json.JSONDecodeError:
+                print(f"Skipping malformed JSON line in {path}")
+    print(f"Loaded {len(test_fixtures)} fixtures for evaluation from {path}")
+
+def evaluate_nlu_tags(expected: Dict[str, Any], actual: Dict[str, Any], tag_key: str, expected_key_override: str = None) -> Dict[str, float]:
+    lookup_key = expected_key_override or tag_key
+    expected_raw = expected.get(lookup_key, [])
+    expected_set = set(expected_raw if isinstance(expected_raw, list) else [expected_raw]) if expected_raw and expected_raw != "None" else set()
+    actual_raw = actual.get(tag_key, [])
+    actual_set = set(actual_raw if isinstance(actual_raw, list) else [actual_raw]) if actual_raw and actual_raw != "None" else set()
+    if not expected_set and not actual_set:
+        return {"precision": 1.0, "recall": 1.0, "f1_score": 1.0}
+    true_positives = len(expected_set.intersection(actual_set))
+    precision = true_positives / len(actual_set) if actual_set else 0.0
+    recall = true_positives / len(expected_set) if expected_set else 0.0
+    f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0
+    return {"precision": precision, "recall": recall, "f1_score": f1_score}
+
+def _parse_judge_json(raw_str: str) -> dict | None:
+    try:
+        start_brace = raw_str.find('{')
+        end_brace = raw_str.rfind('}')
+        if start_brace != -1 and end_brace > start_brace:
+            json_str = raw_str[start_brace : end_brace + 1]
+            return json.loads(json_str)
+        return None
+    except (json.JSONDecodeError, AttributeError):
+        return None
+
+# --- NEW: helpers for categorisation and error-class labelling ---
+def _categorize_test(test_id: str) -> str:
+    tid = (test_id or "").lower()
+    if "synonym" in tid: return "synonym"
+    if "multi_fact" in tid or "multi-hop" in tid or "multihop" in tid: return "multi_fact"
+    if "omission" in tid: return "omission"
+    if "hallucination" in tid: return "hallucination"
+    if "time" in tid or "temporal" in tid: return "temporal"
+    if "context" in tid: return "context_disambig"
+    return "baseline"
+
+def _classify_error(gt: str, gen: str) -> str:
+    import re
+    gt = (gt or "").strip().lower()
+    gen = (gen or "").strip().lower()
+    if not gen:
+        return "empty"
+    if not gt:
+        return "hallucination" if gen else "empty"
+    if gt in gen:
+        return "paraphrase"
+    gt_tokens = set([t for t in re.split(r'\W+', gt) if t])
+    gen_tokens = set([t for t in re.split(r'\W+', gen) if t])
+    overlap = len(gt_tokens & gen_tokens) / max(1, len(gt_tokens))
+    if overlap >= 0.3:
+        return "omission"
+    return "contradiction"
+
+## NEW
+# In evaluate.py
+def run_comprehensive_evaluation(
+    vs_general: FAISS,
+    vs_personal: FAISS,
+    nlu_vectorstore: FAISS,
+    config: Dict[str, Any],
+    storage_path: Path  # <-- ADD THIS PARAMETER
+):
+    global test_fixtures
+    if not test_fixtures:
+        # The return signature is now back to 3 items.
+        return "No test fixtures loaded.", [], []
+
+    vs_personal_test = None
+    personal_context_docs = []
+    personal_context_file = "sample_data/1 Complaints of a Dutiful Daughter.txt"
+
+    if os.path.exists(personal_context_file):
+        print(f"Found personal context file for evaluation: '{personal_context_file}'")
+        with open(personal_context_file, "r", encoding="utf-8") as f:
+            content = f.read()
+            doc = Document(page_content=content, metadata={"source": os.path.basename(personal_context_file)})
+            personal_context_docs.append(doc)
+    else:
+        print(f"WARNING: Personal context file not found at '{personal_context_file}'. Factual tests will likely fail.")
+
+    vs_personal_test = build_or_load_vectorstore(
+        personal_context_docs,
+        index_path="tmp/eval_personal_index",
+        is_personal=True
+    )
+    print(f"Successfully created temporary personal vectorstore with {len(personal_context_docs)} document(s) for this evaluation run.")
+    
+    def _norm(label: str) -> str:
+        label = (label or "").strip().lower()
+        return "factual_question" if "factual" in label else label
+    
+    print("Starting comprehensive evaluation...")
+    results: List[Dict[str, Any]] = []
+    total_fixtures = len(test_fixtures)
+    print(f"\n🚀 STARTING EVALUATION on {total_fixtures} test cases...")
+
+    for i, fx in enumerate(test_fixtures):
+        test_id = fx.get("test_id", "N/A")
+        print(f"--- Processing Test Case {i+1}/{total_fixtures}: ID = {test_id} ---")
+        
+        turns = fx.get("turns") or []
+        api_chat_history = [{"role": t.get("role"), "content": t.get("text")} for t in turns]
+        query = next((t["content"] for t in reversed(api_chat_history) if (t.get("role") or "user").lower() == "user"), "")
+        if not query: continue
+
+        print(f'Query: "{query}"')
+    
+        ground_truth = fx.get("ground_truth", {})
+        expected_route = _norm(ground_truth.get("expected_route", "caregiving_scenario"))
+        expected_tags = ground_truth.get("expected_tags", {})
+        actual_route = _norm(route_query_type(query))
+        route_correct = (actual_route == expected_route)
+        
+        actual_tags: Dict[str, Any] = {}
+        if "caregiving_scenario" in actual_route:
+            actual_tags = detect_tags_from_query(
+                query, nlu_vectorstore=nlu_vectorstore,
+                behavior_options=config["behavior_tags"], emotion_options=config["emotion_tags"],
+                topic_options=config["topic_tags"], context_options=config["context_tags"],
+            )
+
+        behavior_metrics = evaluate_nlu_tags(expected_tags, actual_tags, "detected_behaviors")
+        emotion_metrics  = evaluate_nlu_tags(expected_tags, actual_tags, "detected_emotion")
+        topic_metrics    = evaluate_nlu_tags(expected_tags, actual_tags, "detected_topics")
+        context_metrics  = evaluate_nlu_tags(expected_tags, actual_tags, "detected_contexts")
+
+        final_tags = {}
+        if "caregiving_scenario" in actual_route:
+            final_tags = {
+                "scenario_tag": (actual_tags.get("detected_behaviors") or [None])[0],
+                "emotion_tag":  actual_tags.get("detected_emotion"),
+                "topic_tag": (actual_tags.get("detected_topics") or [None])[0],
+                "context_tags": actual_tags.get("detected_contexts", [])
+            }
+        
+        current_test_role = fx.get("test_role", "patient")
+        rag_chain = make_rag_chain(
+            vs_general, 
+            vs_personal, 
+            role=current_test_role, 
+            for_evaluation=True
+        )
+        
+        t0 = time.time()
+        response = answer_query(rag_chain, query, query_type=actual_route, chat_history=api_chat_history, **final_tags)
+        latency_ms = round((time.time() - t0) * 1000.0, 1)
+        answer_text = response.get("answer", "ERROR")
+        ground_truth_answer = ground_truth.get("ground_truth_answer")
+
+        category = _categorize_test(test_id)
+        error_class = _classify_error(ground_truth_answer, answer_text)
+        
+        expected_sources_set = set(map(str, ground_truth.get("expected_sources", [])))
+        raw_sources = response.get("sources", [])
+        actual_sources_set = set(map(str, raw_sources if isinstance(raw_sources, (list, tuple)) else [raw_sources]))
+
+        print("\n" + "-"*20 + " SOURCE EVALUATION " + "-"*20)
+        print(f"  - Expected: {sorted(list(expected_sources_set))}")
+        print(f"  - Actual:   {sorted(list(actual_sources_set))}")
+        
+        true_positives = expected_sources_set.intersection(actual_sources_set)
+        false_positives = actual_sources_set - expected_sources_set
+        false_negatives = expected_sources_set - actual_sources_set    
+
+        if not false_positives and not false_negatives:
+            print("  - Result: ✅ Perfect Match!")
+        else:
+            if false_positives:
+                print(f"  - 🔻 False Positives (hurts precision): {sorted(list(false_positives))}")
+            if false_negatives:
+                print(f"  - 🔻 False Negatives (hurts recall):    {sorted(list(false_negatives))}")
+        print("-"*59 + "\n")
+
+        context_precision, context_recall = 0.0, 0.0
+        if expected_sources_set or actual_sources_set:
+            tp = len(expected_sources_set.intersection(actual_sources_set))
+            if len(actual_sources_set) > 0: context_precision = tp / len(actual_sources_set)
+            if len(expected_sources_set) > 0: context_recall = tp / len(expected_sources_set)
+        elif not expected_sources_set and not actual_sources_set:
+            context_precision, context_recall = 1.0, 1.0
+
+        print("\n" + "-"*20 + " ANSWER & CORRECTNESS EVALUATION " + "-"*20)
+        print(f"  - Ground Truth Answer: {ground_truth_answer}")
+        print(f"  - Generated Answer:    {answer_text}")
+        print("-" * 59)
+        
+        answer_correctness_score = None
+        if ground_truth_answer and "ERROR" not in answer_text:
+            try:
+                judge_msg = ANSWER_CORRECTNESS_JUDGE_PROMPT.format(ground_truth_answer=ground_truth_answer, generated_answer=answer_text)
+                print(f"  - Judge Prompt Sent:\n{judge_msg}")
+                raw_correctness = call_llm([{"role": "user", "content": judge_msg}], temperature=0.0)
+                print(f"  - Judge Raw Response: {raw_correctness}")
+                correctness_data = _parse_judge_json(raw_correctness)
+                if correctness_data and "correctness_score" in correctness_data:
+                    answer_correctness_score = float(correctness_data["correctness_score"])
+                    print(f"  - Final Score: {answer_correctness_score}")
+            except Exception as e:
+                print(f"ERROR during answer correctness judging: {e}")
+
+        faithfulness = None
+        source_docs = response.get("source_documents", [])
+        if source_docs and "ERROR" not in answer_text:
+            context_blob = "\n---\n".join([doc.page_content for doc in source_docs])
+            judge_msg = FAITHFULNESS_JUDGE_PROMPT.format(query=query, answer=answer_text, sources=context_blob)
+            try:
+                if context_blob.strip():
+                    raw = call_llm([{"role": "user", "content": judge_msg}], temperature=0.0)
+                    data = _parse_judge_json(raw)
+                    if data:
+                        denom = data.get("supported", 0) + data.get("contradicted", 0) + data.get("not_enough_info", 0)
+                        if denom > 0: faithfulness = round(data.get("supported", 0) / denom, 3)
+                        elif data.get("ignored", 0) > 0: faithfulness = 1.0
+            except Exception as e:
+                print(f"ERROR during faithfulness judging: {e}")
+
+        sources_pretty = ", ".join(sorted(s)) if (s:=actual_sources_set) else ""
+        results.append({
+            "test_id": fx.get("test_id", "N/A"), "title": fx.get("title", "N/A"),
+            "route_correct": "✅" if route_correct else "❌", "expected_route": expected_route, "actual_route": actual_route,
+            "behavior_f1": f"{behavior_metrics['f1_score']:.2f}", "emotion_f1": f"{emotion_metrics['f1_score']:.2f}",
+            "topic_f1": f"{topic_metrics['f1_score']:.2f}", "context_f1": f"{context_metrics['f1_score']:.2f}",
+            "generated_answer": answer_text, "sources": sources_pretty, "source_count": len(actual_sources_set),
+            "latency_ms": latency_ms, "faithfulness": faithfulness,
+            "context_precision": context_precision, "context_recall": context_recall,
+            "answer_correctness": answer_correctness_score,
+            "category": category,
+            "error_class": error_class
+        })
+        
+    df = pd.DataFrame(results)
+    summary_text, table_rows, headers = "No valid test fixtures found to evaluate.", [], []
+    
+    if not df.empty:
+        cols = ["test_id", "title", "route_correct", "expected_route", "actual_route", "context_precision", "context_recall", "faithfulness", "answer_correctness", "behavior_f1", "emotion_f1", "topic_f1", "context_f1", "source_count", "latency_ms", "sources", "generated_answer", "category", "error_class"]
+        df = df[[c for c in cols if c in df.columns]]     
+
+        # --- START OF MODIFICATION ---
+        pct = df["route_correct"].value_counts(normalize=True).get("✅", 0) * 100
+        to_f = lambda s: pd.to_numeric(s, errors="coerce")
+        
+        # Calculate the mean for the NLU F1 scores
+        bf1_mean = to_f(df["behavior_f1"]).mean() * 100
+        ef1_mean = to_f(df["emotion_f1"]).mean() * 100
+        tf1_mean = to_f(df["topic_f1"]).mean() * 100
+        cf1_mean = to_f(df["context_f1"]).mean() * 100
+
+        # Add the NLU metrics to the summary f-string
+        summary_text = f"""## Evaluation Summary
+- **Routing Accuracy**: {pct:.2f}%
+- **Behaviour F1 (avg)**: {bf1_mean:.2f}%
+- **Emotion F1 (avg)**: {ef1_mean:.2f}%
+- **Topic F1 (avg)**: {tf1_mean:.2f}%
+- **Context F1 (avg)**: {cf1_mean:.2f}%
+- **RAG: Context Precision**: {(to_f(df["context_precision"]).mean() * 100):.1f}%
+- **RAG: Context Recall**: {(to_f(df["context_recall"]).mean() * 100):.1f}%
+- **RAG: Answer Correctness (LLM-judge)**: {(to_f(df["answer_correctness"]).mean() * 100):.1f}%"""
+        # --- END OF MODIFICATION ---
+        
+        
+        df_display = df.rename(columns={"context_precision": "Ctx. Precision", "context_recall": "Ctx. Recall"})
+        table_rows = df_display.values.tolist()
+        headers = df_display.columns.tolist()
+
+        
+        output_path = "evaluation_results.csv"
+        df.to_csv(output_path, index=False, encoding="utf-8")
+        print(f"Evaluation results saved to {output_path}")
+
+        log_path = storage_path / "evaluation_log.txt"
+        with open(log_path, "w", encoding="utf-8") as logf:
+            logf.write("===== Detailed Evaluation Run =====\n")
+            df_string = df.to_string(index=False)
+            logf.write(df_string)
+            logf.write("\n\n")
+
+            try:
+                cat_means = df.groupby("category")["answer_correctness"].mean().reset_index()
+                print("\n📊 Correctness by Category:")
+                print(cat_means.to_string(index=False))
+                logf.write("\n📊 Correctness by Category:\n")
+                logf.write(cat_means.to_string(index=False))
+                logf.write("\n")
+            except Exception as e:
+                print(f"WARNING: Could not compute category breakdown: {e}")
+
+            try:
+                confusion = pd.crosstab(df["category"], df["error_class"], rownames=["Category"], colnames=["Error Class"], dropna=False)
+                print("\n📊 Error Class Distribution by Category:")
+                print(confusion.to_string())
+                logf.write("\n📊 Error Class Distribution by Category:\n")
+                logf.write(confusion.to_string())
+                logf.write("\n")
+            except Exception as e:
+                print(f"WARNING: Could not build confusion matrix: {e}")
+
+    return summary_text, table_rows, headers
+    # return summary_text, table_rows
+
+## END