Update streamlit.py

streamlit.py

@@ -0,0 +1,634 @@
+# ——— Patch 1: Stop Streamlit watcher hitting torch._classes.__path__ ———
+import torch
+class _DummyPath:
+    def __init__(self):
+        self._path = []
+    def __getattr__(self, name):
+        return []
+torch._classes.__path__ = _DummyPath()
+
+# ——— Patch 2: Make SentenceTransformer.to() fall back to to_empty() on meta modules ———
+import sentence_transformers as _st
+_BaseST = _st.SentenceTransformer
+class SentenceTransformer(_BaseST):
+    def to(self, *args, **kwargs):
+        try:
+            return super().to(*args, **kwargs)
+        except NotImplementedError:
+            return super().to_empty(*args, **kwargs)
+
+# ——— Standard imports ———
+import streamlit as st
+import streamlit.components.v1 as components
+import PyPDF2
+import numpy as np
+from typing import List, Dict
+from langdetect import detect, detect_langs
+from sklearn.metrics.pairwise import cosine_similarity
+import google.generativeai as genai
+from gtts import gTTS
+import speech_recognition as sr
+import tempfile, base64, os
+import requests, time
+import sqlite3
+from datetime import datetime
+import pandas as pd
+import faiss # Import FAISS
+
+# ——— Configuration ———
+GENAI_API_KEY = "AIzaSyA5xtoT9HAjH-wsa7OHFXlBjRRcXwCFBMg"
+DID_API_KEY = "a3Jpc2huYW12aXB1bEBnbWFpbC4Y29t:5DSNuJuWUBZQ0G44TfJlJ" # Replace with your actual D-ID API key
+AVATAR_IMAGE_URL = "https://raw.githubusercontent.com/de-id/live-streaming-demo/main/alex_v2_idle_image.png"
+
+# Ensure data directories exist
+if not os.path.exists("data"):
+    os.makedirs("data")
+if not os.path.exists("data/pdfs"):
+    os.makedirs("data/pdfs")
+if not os.path.exists("data/faiss_indexes"):
+    os.makedirs("data/faiss_indexes")
+
+# ——— SQLite DB Setup ———
+def init_db():
+    conn = sqlite3.connect("interactions.db")
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            password TEXT NOT NULL
+        )
+    """)
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS interactions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER,
+            timestamp TEXT,
+            language TEXT,
+            question TEXT,
+            answer TEXT,
+            FOREIGN KEY (user_id) REFERENCES users (id)
+        )
+    """)
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS documents (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER,
+            filename TEXT NOT NULL,
+            filepath TEXT NOT NULL,
+            faiss_index_path TEXT NOT NULL,
+            language TEXT, -- Store the detected primary language of the document
+            FOREIGN KEY (user_id) REFERENCES users (id)
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+def add_user(username, password):
+    conn = sqlite3.connect("interactions.db")
+    cursor = conn.cursor()
+    try:
+        # NOTE: For production, use a strong hashing library like 'bcrypt' or 'passlib'
+        # For this example, a simple hash() is used, which is NOT SECURE for real applications.
+        cursor.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, hash(password)))
+        conn.commit()
+        return True
+    except sqlite3.IntegrityError:
+        return False # Username already exists
+    finally:
+        conn.close()
+
+def verify_user(username, password):
+    conn = sqlite3.connect("interactions.db")
+    cursor = conn.cursor()
+    # NOTE: For production, use a strong hashing library like 'bcrypt' or 'passlib'
+    cursor.execute("SELECT id FROM users WHERE username = ? AND password = ?", (username, hash(password)))
+    user = cursor.fetchone()
+    conn.close()
+    return user[0] if user else None
+
+def save_interaction(user_id: int, language: str, question: str, answer: str):
+    conn = sqlite3.connect("interactions.db")
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT INTO interactions (user_id, timestamp, language, question, answer)
+        VALUES (?, ?, ?, ?, ?)
+    """, (user_id, datetime.now().isoformat(), language, question, answer))
+    conn.commit()
+    conn.close()
+
+def save_document_metadata(user_id: int, filename: str, filepath: str, faiss_index_path: str, language: str):
+    conn = sqlite3.connect("interactions.db")
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT INTO documents (user_id, filename, filepath, faiss_index_path, language)
+        VALUES (?, ?, ?, ?, ?)
+    """, (user_id, filename, filepath, faiss_index_path, language))
+    conn.commit()
+    conn.close()
+
+def get_user_documents(user_id: int) -> List[Dict]:
+    conn = sqlite3.connect("interactions.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, filename, filepath, faiss_index_path, language FROM documents WHERE user_id = ?", (user_id,))
+    docs = [{"id": row[0], "filename": row[1], "filepath": row[2], "faiss_index_path": row[3], "language": row[4]} for row in cursor.fetchall()]
+    conn.close()
+    return docs
+
+# ——— RAGSingleLanguage class ———
+class RAGSingleLanguage:
+    def __init__(self, api_key: str):
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel('gemini-1.5-flash')
+        self.embedder = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+        self.chunks: List[str] = []
+        self.faiss_index = None
+        self.language: str = 'en' # Default language for translation if not explicitly set
+
+    def detect_languages(self, text: str) -> List[str]:
+        seg_size = 1000
+        probs = {}
+        for i in range(0, len(text), seg_size):
+            seg = text[i:i+seg_size]
+            try:
+                for lang in detect_langs(seg):
+                    probs[lang.lang] = max(probs.get(lang.lang, 0.0), lang.prob)
+            except:
+                continue
+        # Only return languages with a probability >= 0.2
+        langs = [l for l,p in probs.items() if p >= 0.2]
+        # Fallback to English if no strong detection
+        return langs or ['en']
+
+    def translate(self, text: str, tgt: str) -> str:
+        try:
+            src = detect(text)
+        except:
+            src = 'en' # Assume English if detection fails
+        if src.lower() == tgt.lower():
+            return text
+        prompt = f"Translate to {tgt.upper()}:\n\n{text}"
+        try:
+            return self.model.generate_content(prompt).text.strip()
+        except Exception as e:
+            st.warning(f"Translation failed: {e}. Returning original text.")
+            return text
+
+    def process_document(self, pdf_file_path: str, chunk_size: int = 500) -> str:
+        reader = PyPDF2.PdfReader(pdf_file_path)
+        pages = [p.extract_text() or "" for p in reader.pages]
+        full_text = " ".join(pages)
+        
+        # Detect dominant language of the document
+        detected_langs = self.detect_languages(full_text)
+        # We'll store the first detected language as the document's primary language
+        doc_language = detected_langs[0] if detected_langs else 'en'
+        
+        full = full_text.split()
+        self.chunks = [
+            " ".join(full[i:i+chunk_size])
+            for i in range(0, len(full), chunk_size)
+        ]
+        
+        # Generate embeddings
+        embeddings = self.embedder.encode(
+            self.chunks,
+            convert_to_numpy=True,
+            normalize_embeddings=True
+        )
+
+        # Create FAISS index
+        dimension = embeddings.shape[1]
+        self.faiss_index = faiss.IndexFlatL2(dimension)
+        self.faiss_index.add(embeddings)
+        
+        return doc_language # Return the detected language for saving
+
+    def load_faiss_index(self, faiss_index_path: str, document_chunks: List[str]):
+        try:
+            self.faiss_index = faiss.read_index(faiss_index_path)
+            self.chunks = document_chunks # Load associated chunks
+            return True
+        except Exception as e:
+            st.error(f"Error loading FAISS index: {e}")
+            return False
+
+    def set_language(self, lang: str):
+        self.language = lang
+
+    def answer_question(self, question: str, top_k: int = 5) -> str:
+        if self.faiss_index is None or not self.chunks:
+            return "Please select a document to query from."
+
+        q_en = self.translate(question, 'en')
+        q_emb = self.embedder.encode([q_en], convert_to_numpy=True, normalize_embeddings=True)
+
+        # Search FAISS index
+        # D, I are distances and indices respectively.
+        # For normalized embeddings, L2 distance (d) is related to cosine similarity (s) by d^2 = 2(1-s)
+        distances, indices = self.faiss_index.search(q_emb, top_k)
+        
+        contexts = []
+        for i, dist in zip(indices[0], distances[0]):
+            if i >= 0 and i < len(self.chunks): # Ensure index is valid
+                sim_score = 1 - (dist / 2) # Convert L2 distance to cosine similarity for display
+                contexts.append(f"[Score: {sim_score:.2f}]\n{self.chunks[i]}")
+
+        ctx = "\n\n".join(contexts)
+
+        prompt = (
+            "Answer the following question using only the provided context. "
+            "Be accurate and detailed. If the answer is not present, say: "
+            "'I apologize, but I cannot find this information in the documentation. "
+            "Please contact customer support for accurate assistance on this matter.'\n\n"
+            f"Context:\n{ctx}\n\nQuestion: {q_en}"
+        )
+
+        try:
+            out = self.model.generate_content(prompt).text.strip()
+        except Exception as e:
+            return f"Error generating answer: {e}"
+        return self.translate(out, self.language)
+
+# ——— Voice Input ———
+def recognize_voice(lang_code='en-IN') -> str:
+    r = sr.Recognizer()
+    with sr.Microphone() as src:
+        st.info("🎤 Adjusting for ambient noise…")
+        r.adjust_for_ambient_noise(src, duration=1)
+        st.info("Listening…")
+        try:
+            audio = r.listen(src, timeout=10, phrase_time_limit=10)
+        except sr.WaitTimeoutError:
+            st.warning("⏰ No speech detected.")
+            return ""
+    try:
+        return r.recognize_google(audio, language=lang_code)
+    except sr.UnknownValueError:
+        st.error("❗ Could not understand audio.")
+    except sr.RequestError as e:
+        st.error(f"🚫 Speech API error: {e}")
+    return ""
+
+# ——— D-ID Avatar Generator ———
+def generate_did_avatar_video(answer_text: str, image_url: str) -> str:
+    url = "https://api.d-id.com/talks"
+    headers = {
+        "Authorization": f"Basic {base64.b64encode(DID_API_KEY.encode()).decode()}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "source_url": image_url,
+        "script": {
+            "type": "text",
+            "input": answer_text,
+            "provider": {
+                "type": "microsoft",
+                "voice_id": "en-US-GuyNeural", # Default English voice
+                "voice_config": {"style": "Cheerful"}
+            }
+        },
+        "config": {"stitch": True}
+    }
+    response = requests.post(url, json=payload, headers=headers)
+    if response.status_code not in [200, 201]:
+        st.error(f"❌ Avatar video request failed: {response.text}")
+        return ""
+    talk_id = response.json().get("id")
+    if not talk_id:
+        st.error("❌ Talk ID not found in response.")
+        return ""
+    
+    # Poll for video status
+    for _ in range(30): # Try for up to 60 seconds (30 * 2 seconds)
+        time.sleep(2)
+        check = requests.get(f"https://api.d-id.com/talks/{talk_id}", headers=headers)
+        if check.status_code == 200:
+            data = check.json()
+            if data.get("status") == "done":
+                return data.get("result_url")
+            elif data.get("status") == "error":
+                st.error(f"❌ D-ID video generation error: {data.get('error')}")
+                return ""
+    st.warning("⚠️ Avatar video is still processing or timed out.")
+    return ""
+
+# ——— Main App ———
+def main():
+    init_db()
+    st.set_page_config(page_title="Voice‑Viz RAG", page_icon="🔊")
+    st.title("🔊 AI Helpdesk")
+
+    # Initialize all session state variables at the top
+    if 'rag' not in st.session_state:
+        st.session_state.rag = RAGSingleLanguage(GENAI_API_KEY)
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
+        st.session_state.user_id = None
+        st.session_state.username = None
+    if 'selected_doc_id' not in st.session_state:
+        st.session_state.selected_doc_id = None
+        st.session_state.selected_doc_chunks = []
+    if 'current_doc_language' not in st.session_state: # Stores the language of the currently loaded document
+        st.session_state.current_doc_language = 'en'
+    if 'interaction_language' not in st.session_state: # Stores the language chosen for interaction (can differ from doc lang)
+        st.session_state.interaction_language = 'en'
+    if 'voice_q' not in st.session_state: # THIS IS THE FIX FOR THE ATTRIBUTEERROR
+        st.session_state.voice_q = ""
+
+    st.sidebar.header("How to use")
+    st.sidebar.markdown("""
+    1. Login or Sign Up.
+    2. Upload PDF(s) to your account.
+    3. Select a document from your uploads.
+    4. Confirm or change the interaction language.
+    5. Type or speak your question.
+    6. Read or listen to the AI's answer.
+    """)
+
+    if not st.session_state.logged_in:
+        st.subheader("User Authentication")
+        auth_option = st.radio("Choose an option:", ("Login", "Sign Up"))
+
+        with st.form("auth_form"):
+            username = st.text_input("Username")
+            password = st.text_input("Password", type="password")
+            submitted = st.form_submit_button("Submit")
+
+            if submitted:
+                if auth_option == "Login":
+                    user_id = verify_user(username, password)
+                    if user_id:
+                        st.session_state.logged_in = True
+                        st.session_state.user_id = user_id
+                        st.session_state.username = username
+                        st.success(f"Welcome, {username}!")
+                        st.rerun() # Rerun to switch to the main app view
+                    else:
+                        st.error("Invalid username or password.")
+                elif auth_option == "Sign Up":
+                    if add_user(username, password):
+                        st.success("Account created successfully! Please log in.")
+                    else:
+                        st.error("Username already exists. Please choose a different one.")
+    else:
+        st.sidebar.write(f"Logged in as: **{st.session_state.username}**")
+        if st.sidebar.button("Logout"):
+            st.session_state.logged_in = False
+            st.session_state.user_id = None
+            st.session_state.username = None
+            st.session_state.selected_doc_id = None
+            st.session_state.selected_doc_chunks = []
+            st.session_state.current_doc_language = 'en'
+            st.session_state.interaction_language = 'en'
+            st.session_state.voice_q = "" # Reset voice input
+            st.session_state.rag = RAGSingleLanguage(GENAI_API_KEY) # Reset RAG instance
+            st.rerun()
+
+        st.subheader("Document Management")
+        uploaded_file = st.file_uploader("Upload your PDF manual(s)", type="pdf", accept_multiple_files=True)
+        
+        if uploaded_file:
+            for file in uploaded_file:
+                # Check if the file (by name) is already uploaded by this user
+                existing_docs = get_user_documents(st.session_state.user_id)
+                if file.name in [doc['filename'] for doc in existing_docs]:
+                    st.info(f"Document '{file.name}' already uploaded by you.")
+                    continue # Skip to the next file if already exists
+
+                with st.spinner(f"Processing {file.name}…"):
+                    # Save PDF to disk
+                    pdf_path = os.path.join("data", "pdfs", file.name)
+                    with open(pdf_path, "wb") as f:
+                        f.write(file.getbuffer())
+
+                    # Process document and get its primary language
+                    doc_language = st.session_state.rag.process_document(pdf_path)
+                    
+                    # Save FAISS index
+                    faiss_index_filename = f"{os.path.splitext(file.name)[0]}_{st.session_state.user_id}.faiss"
+                    faiss_index_path = os.path.join("data", "faiss_indexes", faiss_index_filename)
+                    faiss.write_index(st.session_state.rag.faiss_index, faiss_index_path)
+
+                    # Save chunks separately (FAISS only stores embeddings, not the text chunks)
+                    chunks_filename = f"{os.path.splitext(file.name)[0]}_{st.session_state.user_id}.chunks"
+                    chunks_path = os.path.join("data", "faiss_indexes", chunks_filename)
+                    with open(chunks_path, "w", encoding="utf-8") as f:
+                        # Use a unique delimiter that is unlikely to appear in the text
+                        f.write("\n--CHUNK_DELIMITER--\n".join(st.session_state.rag.chunks)) 
+
+                    # Save document metadata to DB
+                    save_document_metadata(st.session_state.user_id, file.name, pdf_path, faiss_index_path, doc_language)
+                st.success(f"✅ Document '{file.name}' processed and saved!")
+            st.rerun() # Rerun to refresh the document list
+
+        # Display and allow selection of user's uploaded documents
+        user_docs = get_user_documents(st.session_state.user_id)
+        if user_docs:
+            doc_options_display = {doc['filename']: doc for doc in user_docs}
+            # Add an empty option for "No document selected"
+            selected_filename = st.selectbox(
+                "Select a document to query:", 
+                [""] + list(doc_options_display.keys()),
+                key="doc_selector" # Add a key to avoid potential widget errors
+            )
+
+            # Logic to load selected document's FAISS index and chunks
+            if selected_filename and selected_filename != "":
+                selected_doc_info = doc_options_display[selected_filename]
+                
+                # Check if this document is already loaded
+                if st.session_state.selected_doc_id != selected_doc_info['id']:
+                    st.session_state.selected_doc_id = selected_doc_info['id']
+                    
+                    chunks_filename = f"{os.path.splitext(selected_doc_info['filename'])[0]}_{st.session_state.user_id}.chunks"
+                    chunks_path = os.path.join("data", "faiss_indexes", chunks_filename)
+                    
+                    if os.path.exists(chunks_path):
+                        with open(chunks_path, "r", encoding="utf-8") as f:
+                            st.session_state.selected_doc_chunks = f.read().split("\n--CHUNK_DELIMITER--\n")
+                    else:
+                        st.error("Error: Chunks file not found for this document.")
+                        st.session_state.selected_doc_chunks = []
+                        st.session_state.selected_doc_id = None # Invalidate selection
+
+                    if st.session_state.selected_doc_id and \
+                       st.session_state.rag.load_faiss_index(selected_doc_info['faiss_index_path'], st.session_state.selected_doc_chunks):
+                        st.success(f"Selected document: '{selected_filename}'")
+                        # Set the detected language of the document
+                        st.session_state.current_doc_language = selected_doc_info['language']
+                        st.session_state.interaction_language = selected_doc_info['language'] # Default interaction language to doc's
+                        st.session_state.rag.set_language(st.session_state.interaction_language)
+                        st.rerun() # Rerun to update language selector and clear old inputs
+                    else:
+                        st.error(f"Could not load FAISS index for '{selected_filename}'.")
+                        st.session_state.selected_doc_id = None
+                        st.session_state.rag.faiss_index = None
+                        st.session_state.rag.chunks = []
+                        st.session_state.current_doc_language = 'en'
+                        st.session_state.interaction_language = 'en'
+                
+                # If a document is selected and loaded, allow language choice for interaction
+                if st.session_state.selected_doc_id:
+                    st.markdown("---") # Separator for clarity
+                    st.markdown("**Choose Interaction Language**")
+                    
+                    # You could fetch all detected languages from the processed document if desired
+                    # For simplicity, we'll offer a few common ones, plus the detected document language
+                    available_langs = sorted(list(set(['en', 'hi', 'fr', 'es', 'de', st.session_state.current_doc_language])))
+                    # Remove duplicates and ensure the current_doc_language is an option
+                    
+                    lang_selection = st.selectbox(
+                        "Select the language for your question and the AI's answer:",
+                        [lang.upper() for lang in available_langs],
+                        index=available_langs.index(st.session_state.interaction_language) if st.session_state.interaction_language in available_langs else 0,
+                        key="interaction_lang_selector"
+                    )
+                    
+                    if lang_selection:
+                        new_lang = lang_selection.lower()
+                        if new_lang != st.session_state.interaction_language:
+                            st.session_state.interaction_language = new_lang
+                            st.session_state.rag.set_language(new_lang)
+                            st.rerun() # Rerun to update the question input field's language
+                    
+                    st.markdown(f"**Asking in:** `{st.session_state.interaction_language.upper()}`")
+                    st.markdown("---") # Separator
+
+                    st.markdown("**Type your question**")
+                    typed_question = st.text_input(f"Ask in {st.session_state.interaction_language.upper()}:", value=st.session_state.voice_q, key="typed_question_input")
+                    
+                    st.markdown("**Or use voice input**")
+                    if st.button("🎙️ Speak Your Question", key="speak_button"):
+                        # Adjust language code for speech recognition based on interaction language
+                        recognizer_lang_code = st.session_state.interaction_language
+                        if recognizer_lang_code == "en":
+                            recognizer_lang_code = "en-IN" # Default to Indian English for better recognition in some cases
+                        elif recognizer_lang_code == "hi":
+                            recognizer_lang_code = "hi-IN" # Hindi
+                        # Add more specific regional codes if necessary for other languages
+
+                        recd_speech = recognize_voice(recognizer_lang_code)
+                        if recd_speech:
+                            st.session_state.voice_q = recd_speech
+                            st.success(f"🎤 You said: {recd_speech}")
+                            st.rerun() # Rerun to populate the text input with spoken text
+                        else:
+                            st.warning("No speech recognized.")
+
+                    # Use the typed input or the voice input if available
+                    question_to_process = typed_question or st.session_state.voice_q
+
+                    if st.button("Get Answer", key="get_answer_button") and question_to_process:
+                        st.markdown(f"🔍 Question: `{question_to_process}`")
+                        with st.spinner("Thinking…"):
+                            answer = st.session_state.rag.answer_question(question_to_process)
+                        st.markdown(f"**Answer ({st.session_state.interaction_language.upper()}):** {answer}")
+
+                        # Save to DB
+                        save_interaction(st.session_state.user_id, st.session_state.interaction_language, question_to_process, answer)
+
+                        # Text-to-Speech (gTTS)
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as fp:
+                            try:
+                                gTTS(text=answer, lang=st.session_state.interaction_language).save(fp.name)
+                                mp3_bytes = open(fp.name, "rb").read()
+                                b64 = base64.b64encode(mp3_bytes).decode()
+
+                                html = f"""
+                                <audio id='player' controls>
+                                  <source src='data:audio/mp3;base64,{b64}' type='audio/mp3'/>
+                                </audio>
+                                <canvas id='canvas' width='300' height='100'></canvas>
+                                <script>
+                                  const audio = document.getElementById('player');
+                                  const canvas = document.getElementById('canvas');
+                                  const ctx = canvas.getContext('2d');
+                                  const audioCtx = new (window.AudioContext||window.webkitAudioContext)();
+                                  const source = audioCtx.createMediaElementSource(audio);
+                                  const analyser = audioCtx.createAnalyser();
+                                  analyser.fftSize = 256;
+                                  source.connect(analyser);
+                                  analyser.connect(audioCtx.destination);
+                                  const data = new Uint8Array(analyser.frequencyBinCount);
+                                  function drawLine() {{
+                                    requestAnimationFrame(drawLine);
+                                    analyser.getByteTimeDomainData(data);
+                                    let sum = 0;
+                                    for (let i=0; i<data.length; i++) {{
+                                      const v = data[i] - 128;
+                                      sum += v*v;
+                                    }}
+                                    const rms = Math.sqrt(sum/data.length);
+                                    const maxLen = canvas.width / 2 * (rms/128);
+                                    const y = canvas.height / 2;
+                                    ctx.clearRect(0, 0, canvas.width, canvas.height);
+                                    ctx.beginPath();
+                                    ctx.moveTo((canvas.width / 2) - maxLen, y);
+                                    ctx.lineTo((canvas.width / 2) + maxLen, y);
+                                    ctx.lineWidth = 4;
+                                    ctx.strokeStyle = '#4CAF50';
+                                    ctx.stroke();
+                                  }}
+                                  audio.onplay = () => {{
+                                    audioCtx.resume().then(() => drawLine());
+                                  }};
+                                </script>
+                                """
+                                components.html(html, height=150)
+                            except Exception as e:
+                                st.error(f"Error generating audio: {e}. Please ensure gTTS supports '{st.session_state.interaction_language}'.")
+                        
+                        # Clear voice_q after processing the answer
+                        st.session_state.voice_q = "" 
+
+                        st.markdown("### 🧑‍💼 Speaking AI Avatar")
+                        with st.spinner("Generating avatar video…"):
+                            video_url = generate_did_avatar_video(answer, AVATAR_IMAGE_URL)
+                            if video_url:
+                                st.video(video_url)
+                            else:
+                                st.error("Failed to load avatar video.")
+                    elif st.button("Get Answer") and not question_to_process:
+                        st.warning("Please enter or speak a question.")
+            else:
+                st.info("Please select a document from your uploaded files to start querying.")
+                # Reset RAG if no document is selected
+                st.session_state.selected_doc_id = None
+                st.session_state.rag.faiss_index = None
+                st.session_state.rag.chunks = []
+                st.session_state.current_doc_language = 'en'
+                st.session_state.interaction_language = 'en'
+                st.session_state.rag.set_language('en') # Reset RAG's internal language
+        else:
+            st.info("No documents uploaded yet. Please upload a PDF to begin.")
+
+    # --- Optional: Admin View ---
+    st.sidebar.markdown("---")
+    st.sidebar.header("Admin Views")
+
+    if st.sidebar.checkbox("📜 Show Past Interactions"):
+        if st.session_state.logged_in:
+            conn = sqlite3.connect("interactions.db")
+            df = pd.read_sql_query(f"SELECT timestamp, language, question, answer FROM interactions WHERE user_id = {st.session_state.user_id} ORDER BY timestamp DESC", conn)
+            if not df.empty:
+                st.sidebar.dataframe(df)
+            else:
+                st.sidebar.info("No past interactions for this user.")
+            conn.close()
+        else:
+            st.sidebar.warning("Please log in to view past interactions.")
+
+    if st.sidebar.checkbox("📂 Show My Uploaded Documents"):
+        if st.session_state.logged_in:
+            user_docs = get_user_documents(st.session_state.user_id)
+            if user_docs:
+                df_docs = pd.DataFrame(user_docs)
+                st.sidebar.dataframe(df_docs[['filename', 'language']])
+            else:
+                st.sidebar.info("No documents uploaded yet.")
+        else:
+            st.sidebar.warning("Please log in to view your uploaded documents.")
+
+if __name__ == "__main__":
+    main()