revisi 1

.gitignore

@@ -4,4 +4,6 @@
 /tests/__pycache__
 /app/scrapping/*.py
 /vector_store_data
-/hasil_evaluasi
+/hasil_evaluasi
+/app/data
+/cache_tts

app.py

@@ -2,150 +2,62 @@ import streamlit as st
 import os
 from dotenv import load_dotenv
 from langsmith import traceable
-from datetime import datetime
-from typing import List, Dict, Optional
 
-from app.chat import initialize_session_state, display_chat_history
-from app.data_loader import get_data, list_all_files, load_docs
+from app.chat import (
+    initialize_session_state,
+    display_chat_history,
+)
+from app.data_loader import get_data, load_docs
 from app.document_processor import process_documents, save_vector_store_to_supabase, load_vector_store_from_supabase
-from app.prompts import sahabat_prompt
 from app.db import supabase
-from langchain_community.llms import Replicate
-from langchain.memory import ConversationBufferMemory
-from langchain.chains import ConversationalRetrievalChain
-from langchain_community.document_transformers import LongContextReorder
+from app.config import Config
+# Modularized helpers
+import app.rag as rag
+import app.vector_store as vs
+import app.auth as auth
+import app.ui as ui
+from app.session import restore_user_session_if_needed, ensure_active_session
+from app.workflows import prepare_vector_store_if_needed
+from uuid import uuid4
 
 load_dotenv()
 
 
-#  CONFIG
-
-BUCKET_NAME = "pnp-bot-storage-archive"
-VECTOR_STORE_PREFIX = "vector_store"
-
-
-#  UTILITY
-
-def get_latest_data_timestamp_from_files(bucket_name: str) -> float:
-    """Get the latest timestamp from files in a Supabase storage bucket."""
-    files = list_all_files(bucket_name)
-    latest_time = 0.0
-    for file in files:
-        iso_time = file.get("updated_at") or file.get("created_at")
-        if iso_time:
-            try:
-                timestamp = datetime.fromisoformat(iso_time.replace('Z', '+00:00')).timestamp()
-                latest_time = max(latest_time, timestamp)
-            except Exception as e:
-                print(f"Gagal parsing waktu dari {file.get('name')}: {e}")
-    return latest_time
-
-
-def get_supabase_vector_store_timestamp() -> Optional[str]:
-    """Get the latest timestamp of vector store files in the Supabase storage."""
-    try:
-        response = supabase.storage.from_(BUCKET_NAME).list()
-        timestamps = []
-        for file in response:
-            if file["name"].startswith(VECTOR_STORE_PREFIX) and (
-                file["name"].endswith(".faiss") or file["name"].endswith(".pkl")
-            ):
-                timestamps.append(file["updated_at"])
-        if len(timestamps) >= 2:
-            return max(timestamps)
-        return None
-    except Exception as e:
-        print(f"Error getting Supabase timestamp: {e}")
-        return None
-
-
-def vector_store_is_outdated() -> bool:
-    """Check if vector store needs to be updated based on files in Supabase storage."""
-    supabase_timestamp = get_supabase_vector_store_timestamp()
-    if supabase_timestamp is None:
-        return True
-    supabase_time = datetime.fromisoformat(supabase_timestamp.replace("Z", "+00:00")).timestamp()
-    data_time = get_latest_data_timestamp_from_files("pnp-bot-storage")
-
-    return data_time > supabase_time
-
-
-def reorder_embedding(docs):
-    """Reorder documents for long context retrieval."""
-    reordering = LongContextReorder()
-    return reordering.transform_documents(docs)
-
-
-
-#  RAG CHAIN
-
-@traceable(name="Create RAG Conversational Chain")
-def create_conversational_chain(vector_store):
-    """Create a Conversational Retrieval Chain for RAG."""
-    llm = Replicate(
-        model="fauzi3007/sahabat-ai-replicate:c3fc398f441379bd3fb6a4498950f9302aa75b7a95e76978a689ceb5c4b4bf09",
-        model_kwargs={"temperature": 0.1, "top_p": 0.9, "max_new_tokens": 10000}
-    )
-    memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True, output_key="answer")
-    chain = ConversationalRetrievalChain.from_llm(
-        llm,
-        retriever=vector_store.as_retriever(search_kwargs={"k": 6}),
-        combine_docs_chain_kwargs={"prompt": sahabat_prompt},
-        return_source_documents=True,
-        memory=memory,
-    )
-    return chain
-
-
-def get_rag_chain(vector_store):
-    """Return a Conversational Retrieval Chain for external use."""
-    return create_conversational_chain(vector_store)
-
-
-
-#  MAIN FUNCTION
+BUCKET_NAME = Config.BUCKET_NAME
+VECTOR_STORE_PREFIX = Config.VECTOR_STORE_PREFIX
 
 @traceable(name="Main Chatbot RAG App")
 def main():
+    try:
+        load_dotenv()
+    except Exception:
+        pass
     initialize_session_state()
     st.set_page_config(
         page_title="PNP-Bot", 
-        page_icon="logo-pnp.ico",             
+        page_icon="favicon.ico",             
     )
-    vector_store = None
-
-    if len(st.session_state["history"]) == 0:
-        if vector_store_is_outdated():
-            with st.spinner("Memuat dan memproses dokumen..."):
-                get_data()
-                docs = load_docs()
-                if len(docs) > 0:
-                    reordered_docs = reorder_embedding(docs)
-                    vector_store = process_documents(reordered_docs)
-
-                    with st.spinner("Mengunggah vector store ke Supabase..."):
-                        success = save_vector_store_to_supabase(vector_store, supabase, BUCKET_NAME, VECTOR_STORE_PREFIX)
-                        if success:
-                            print("✅ Vector store berhasil diunggah ke Supabase!")
-                        else:
-                            print("❌ Gagal mengunggah vector store ke Supabase.")
-                else:
-                    print("⚠️ Folder 'data/' kosong. Chatbot tetap bisa digunakan, tetapi tanpa konteks dokumen.")
-                    vector_store = None
-        else:
-            with st.spinner("Memuat vector store dari Supabase..."):
-                vector_store = load_vector_store_from_supabase(supabase, BUCKET_NAME, VECTOR_STORE_PREFIX)
-                if vector_store:
-                    print("✅ Vector store berhasil dimuat dari Supabase!")
-                else:
-                    print("❌ Gagal memuat vector store dari Supabase.")
-    else:
-        vector_store = st.session_state.get("vector_store") or load_vector_store_from_supabase(supabase, BUCKET_NAME, VECTOR_STORE_PREFIX)
-
+    # Try restore Supabase session if user missing
+    restore_user_session_if_needed()
+    # Authentication gate
+    user = st.session_state.get("user")
+    if not user:
+        auth.auth_view()
+        return
+
+    # Ensure we have an active chat session
+    ensure_active_session(user["id"])
+
+    # Sidebar: delegate completely to UI module
+    with st.sidebar:
+        ui.render_sidebar_sessions()
+
+    # Vector store orchestration (delegated)
+    vector_store = prepare_vector_store_if_needed(len(st.session_state["history"]))
     st.session_state["vector_store"] = vector_store
 
     if st.session_state["vector_store"] is not None:
-        chain = create_conversational_chain(st.session_state["vector_store"])
+        chain = rag.create_conversational_chain(st.session_state["vector_store"])
         display_chat_history(chain)
 
 

app/auth.py

@@ -0,0 +1,190 @@
+import os
+import base64
+import streamlit as st
+from app.db import supabase
+
+
+def auth_view():
+    """Render Supabase authentication with Login, Register, and Forgot Password tabs."""
+    # Wrapper (centered) for all auth content
+    left, center, right = st.columns([1, 2, 1])
+    with center:
+        # Header: smaller PNP logo and centered title
+        # Path logo
+        logo_path = os.path.join("assets", "pnp-logo.png")
+
+        # Convert ke base64 biar bisa di-embed langsung
+        def get_base64_image(path):
+            with open(path, "rb") as f:
+                return base64.b64encode(f.read()).decode()
+
+        encoded_logo = get_base64_image(logo_path)
+
+        # Render dalam satu div center
+        st.markdown(
+            f"""
+            <div style="text-align:center;">
+                <img src="data:image/png;base64,{encoded_logo}" width="100">
+                <h1 style="margin-top:0.25rem;">PNP bot</h1>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+
+        # --- Password recovery handler (Supabase redirect) ---
+        # 1) Move hash params to query params on first load, then reload once
+        if not st.session_state.get("_hash_migrated"):
+            st.markdown(
+                """
+                <script>
+                (function(){
+                  const hash = window.location.hash.startsWith('#') ? window.location.hash.substring(1) : window.location.hash;
+                  if (hash && !window.__hashMigrated) {
+                    const h = new URLSearchParams(hash);
+                    const qp = new URLSearchParams(window.location.search);
+                    for (const [k,v] of h.entries()) { qp.set(k, v); }
+                    const newUrl = window.location.pathname + '?' + qp.toString();
+                    window.history.replaceState(null, '', newUrl);
+                    window.location.hash = '';
+                    window.__hashMigrated = true;
+                    window.location.reload();
+                  }
+                })();
+                </script>
+                """,
+                unsafe_allow_html=True,
+            )
+            st.session_state["_hash_migrated"] = True
+
+        # 2) Read query params for recovery flow
+        try:
+            qp = st.query_params  # Streamlit >= 1.30
+            get_q = lambda k: qp.get(k, None)
+        except Exception:
+            qp = st.experimental_get_query_params()
+            get_q = lambda k: (qp.get(k, [None])[0] if isinstance(qp.get(k, None), list) else qp.get(k, None))
+
+        q_type = get_q("type")
+        if q_type == "recovery":
+            st.info("Reset password: silakan masukkan password baru Anda.")
+            access_token = get_q("access_token")
+            refresh_token = get_q("refresh_token")
+            with st.form("reset_password_form"):
+                npw = st.text_input("Password Baru", type="password")
+                npw2 = st.text_input("Konfirmasi Password Baru", type="password")
+                submit_reset = st.form_submit_button("Set Password Baru")
+            if submit_reset:
+                if not npw or len(npw) < 6:
+                    st.error("Password minimal 6 karakter.")
+                elif npw != npw2:
+                    st.error("Konfirmasi password tidak sama.")
+                elif not access_token or not refresh_token:
+                    st.error("Token pemulihan tidak ditemukan. Coba klik ulang tautan dari email.")
+                else:
+                    try:
+                        # Set current session using tokens from redirect
+                        supabase.auth.set_session(access_token, refresh_token)
+                        # Update user password
+                        supabase.auth.update_user({"password": npw})
+                        st.success("Password berhasil diubah. Silakan login kembali.")
+                        # Optional: clear recovery query params
+                        try:
+                            # Best-effort to clear params
+                            st.markdown(
+                                """
+                                <script>
+                                (function(){
+                                  const qp = new URLSearchParams(window.location.search);
+                                  ["type","access_token","refresh_token","expires_in","expires_at","token_type"].forEach(k=>qp.delete(k));
+                                  const newUrl = window.location.pathname + (qp.toString()?('?'+qp.toString()):'');
+                                  window.history.replaceState(null, '', newUrl);
+                                })();
+                                </script>
+                                """,
+                                unsafe_allow_html=True,
+                            )
+                        except Exception:
+                            pass
+                    except Exception as e:
+                        st.error(f"Gagal mengubah password: {e}")
+            # When in recovery mode, do not render login/register tabs
+            return
+
+        # Auth tabs inside wrapper
+        tab_login, tab_register, tab_forgot = st.tabs(["Login", "Register", "Forgot Password"])
+
+        with tab_login:
+            with st.form("login_form"):
+                email = st.text_input("Email")
+                password = st.text_input("Password", type="password")
+                submitted = st.form_submit_button("Login")
+            if submitted:
+                # Demo password fallback
+                shared_pw = os.getenv("APP_DEMO_PASSWORD")
+                if shared_pw and password == shared_pw:
+                    st.session_state["user"] = {"id": "demo-user", "email": email or "[email protected]"}
+                    st.success("Login demo berhasil")
+                    st.rerun()
+                try:
+                    auth_res = supabase.auth.sign_in_with_password({
+                        "email": email,
+                        "password": password,
+                    })
+                    user = getattr(auth_res, "user", None)
+                    if user:
+                        st.session_state["user"] = {"id": user.id, "email": getattr(user, "email", email)}
+                        session_obj = getattr(auth_res, "session", None)
+                        if session_obj:
+                            st.session_state["sb_session"] = {
+                                "access_token": getattr(session_obj, "access_token", None),
+                                "refresh_token": getattr(session_obj, "refresh_token", None),
+                            }
+                        st.success("Login berhasil")
+                        st.rerun()
+                    else:
+                        st.error("Email atau password salah.")
+                except Exception as e:
+                    st.error(f"Gagal login: {e}")
+
+        with tab_register:
+            st.caption("Buat akun baru. Anda akan menerima email konfirmasi.")
+            with st.form("register_form"):
+                r_email = st.text_input("Email", key="reg_email")
+                r_password = st.text_input("Password", type="password", key="reg_password")
+                r_password2 = st.text_input("Konfirmasi Password", type="password", key="reg_password2")
+                submitted_r = st.form_submit_button("Register")
+            if submitted_r:
+                if r_password != r_password2:
+                    st.error("Password tidak sama.")
+                else:
+                    try:
+                        # Prefer explicit env, then generic site URL, then localhost for dev
+                        redirect_url = os.getenv(
+                            "SUPABASE_EMAIL_REDIRECT",
+                            os.getenv("NEXT_PUBLIC_SITE_URL", "http://localhost:8501"),
+                        )
+                        supabase.auth.sign_up({
+                            "email": r_email,
+                            "password": r_password,
+                            "options": {"email_redirect_to": redirect_url}
+                        })
+                        st.success("Registrasi berhasil. Silakan cek email untuk konfirmasi.")
+                    except Exception as e:
+                        st.error(f"Gagal registrasi: {e}")
+
+        with tab_forgot:
+            st.caption("Kirim tautan reset password ke email Anda.")
+            with st.form("forgot_form"):
+                f_email = st.text_input("Email", key="forgot_email")
+                submitted_f = st.form_submit_button("Kirim Link Reset")
+            if submitted_f:
+                try:
+                    # Prefer explicit env, then generic site URL, then localhost for dev
+                    redirect_url = os.getenv(
+                        "SUPABASE_EMAIL_REDIRECT",
+                        os.getenv("NEXT_PUBLIC_SITE_URL", "http://localhost:8501"),
+                    )
+                    supabase.auth.reset_password_for_email(f_email, {"redirect_to": redirect_url})
+                    st.success("Email reset password telah dikirim. Periksa kotak masuk Anda.")
+                except Exception as e:
+                    st.error(f"Gagal mengirim email reset password: {e}")

app/chat.py

@@ -12,6 +12,7 @@ import os
 import glob
 import time
 from dotenv import load_dotenv
+from uuid import uuid4
 
 load_dotenv()
 
@@ -53,6 +54,207 @@ def initialize_session_state():
         st.session_state['tts_output'] = ""
     if 'tts_played' not in st.session_state:
         st.session_state['tts_played'] = True  
+    if 'session_id' not in st.session_state:
+        st.session_state['session_id'] = str(uuid4())
+
+def _current_user():
+    return st.session_state.get('user')
+
+def save_message_to_supabase(user_id: str, session_id: str, role: str, content: str):
+    try:
+        supabase.table("chat_messages").insert({
+            "user_id": user_id,
+            "session_id": session_id,
+            "role": role,
+            "content": content,
+        }).execute()
+    except Exception as e:
+        # Non-fatal in UI; log to console
+        print(f"Gagal menyimpan pesan: {e}")
+
+def load_history_from_supabase(user_id: str, session_id: str, limit: int = 100):
+    try:
+        res = (
+            supabase
+            .table("chat_messages")
+            .select("role, content, created_at")
+            .eq("user_id", user_id)
+            .eq("session_id", session_id)
+            .order("created_at", desc=False)
+            .limit(limit)
+            .execute()
+        )
+        rows = getattr(res, 'data', None) or []
+        past, generated, history = [], [], []
+        # Bootstrap greeting if empty
+        if not rows:
+            return past, generated, history
+        for r in rows:
+            if r["role"] == "user":
+                past.append(r["content"])
+            elif r["role"] == "assistant":
+                generated.append(r["content"])
+            # Build history pairs progressively when both sides exist
+        # Reconstruct history as list of (user, assistant) tuples
+        for i in range(min(len(past), len(generated))):
+            history.append((past[i], generated[i]))
+        return past, generated, history
+    except Exception as e:
+        print(f"Gagal memuat riwayat: {e}")
+        return [], [], []
+
+def create_chat_session(user_id: str, title: str = None) -> str:
+    """Create a new chat session for user and return session_id."""
+    try:
+        payload = {"user_id": user_id}
+        if title:
+            payload["title"] = title
+        res = (
+            supabase
+            .table("chat_sessions")
+            .insert(payload)
+            .execute()
+        )
+        data = getattr(res, 'data', None) or []
+        if isinstance(data, list) and data:
+            return data[0].get('id') or str(uuid4())
+        if isinstance(data, dict) and data.get('id'):
+            return data['id']
+        return str(uuid4())
+    except Exception as e:
+        print(f"Gagal membuat sesi: {e}")
+        return str(uuid4())
+
+def list_chat_sessions(user_id: str, limit: int = 20):
+    """List recent chat sessions for a user, newest first."""
+    try:
+        res = (
+            supabase
+            .table("chat_sessions")
+            .select("id, title, created_at")
+            .eq("user_id", user_id)
+            .order("created_at", desc=True)
+            .limit(limit)
+            .execute()
+        )
+        data = getattr(res, 'data', None) or []
+        return data
+    except Exception as e:
+        print(f"Gagal memuat daftar sesi: {e}")
+        return []
+
+def delete_chat_session(user_id: str, session_id: str) -> bool:
+    """Delete a single chat session and its messages for a user."""
+    try:
+        # Delete messages first (FK safety)
+        try:
+            supabase.table("chat_messages").delete().eq("user_id", user_id).eq("session_id", session_id).execute()
+        except Exception as e:
+            # If messages table missing/empty, continue
+            print(f"Info: hapus pesan sesi gagal/abaikan: {e}")
+        # Delete the session row
+        supabase.table("chat_sessions").delete().eq("user_id", user_id).eq("id", session_id).execute()
+        return True
+    except Exception as e:
+        print(f"Gagal menghapus sesi: {e}")
+        return False
+
+def delete_all_chat_sessions(user_id: str) -> bool:
+    """Delete all chat sessions and all messages for a user."""
+    try:
+        # Delete all messages for user
+        try:
+            supabase.table("chat_messages").delete().eq("user_id", user_id).execute()
+        except Exception as e:
+            print(f"Info: hapus semua pesan gagal/abaikan: {e}")
+        # Delete all sessions for user
+        supabase.table("chat_sessions").delete().eq("user_id", user_id).execute()
+        return True
+    except Exception as e:
+        print(f"Gagal menghapus semua sesi: {e}")
+        return False
+
+def ensure_chat_session(user_id: str, session_id: str, title: str = None) -> str:
+    """Ensure a chat session with given id exists; create if missing. Returns the session id."""
+    try:
+        # Check existence
+        chk = (
+            supabase
+            .table("chat_sessions")
+            .select("id")
+            .eq("id", session_id)
+            .limit(1)
+            .execute()
+        )
+        data = getattr(chk, 'data', None) or []
+        if (isinstance(data, list) and data) or (isinstance(data, dict) and data.get('id')):
+            return session_id
+    except Exception:
+        pass
+    # Create with explicit id
+    try:
+        payload = {"id": session_id, "user_id": user_id}
+        if title:
+            payload["title"] = title
+        ins = (
+            supabase
+            .table("chat_sessions")
+            .insert(payload)
+            .execute()
+        )
+        data = getattr(ins, 'data', None) or []
+        if isinstance(data, list) and data:
+            return data[0].get('id', session_id)
+        if isinstance(data, dict) and data.get('id'):
+            return data.get('id', session_id)
+        return session_id
+    except Exception as e:
+        print(f"Gagal memastikan sesi: {e}")
+        return session_id
+
+def _generate_session_title_from_text(text: str, max_len: int = 60) -> str:
+    """Generate a concise session title from the first user message."""
+    if not text:
+        return "Percakapan Baru"
+    # Normalize whitespace and strip
+    t = " ".join(text.strip().split())
+    # Remove surrounding quotes or trailing punctuation if too noisy
+    t = t.strip('"\'\u201c\u201d')
+    if len(t) > max_len:
+        t = t[:max_len - 1].rstrip() + "…"
+    return t or "Percakapan Baru"
+
+def update_chat_session_title_if_empty(user_id: str, session_id: str, candidate_title: str) -> None:
+    """If session has no title, set it to candidate_title."""
+    try:
+        chk = (
+            supabase
+            .table("chat_sessions")
+            .select("id, title")
+            .eq("id", session_id)
+            .eq("user_id", user_id)
+            .limit(1)
+            .execute()
+        )
+        rows = getattr(chk, 'data', None) or []
+        title_val = None
+        if isinstance(rows, list) and rows:
+            title_val = rows[0].get("title")
+        elif isinstance(rows, dict):
+            title_val = rows.get("title")
+        if not title_val:
+            safe_title = _generate_session_title_from_text(candidate_title)
+            (
+                supabase
+                .table("chat_sessions")
+                .update({"title": safe_title})
+                .eq("id", session_id)
+                .eq("user_id", user_id)
+                .execute()
+            )
+    except Exception as e:
+        # Non-fatal; just log
+        print(f"Gagal mengatur judul sesi: {e}")
 
 # edge-tts fallback (cadangan)
 async def generate_audio_edge(text, path, voice="id-ID-GadisNeural"):
@@ -95,9 +297,28 @@ def text_to_speech(text):
         return ""
 
 def conversation_chat(query, chain, history):
+    # Save user message first
+    user = _current_user()
+    if user:
+        try:
+            save_message_to_supabase(user_id=user["id"], session_id=st.session_state.get('session_id'), role="user", content=query)
+        except Exception:
+            pass
+        # Try auto-name the session on first user message
+        try:
+            update_chat_session_title_if_empty(user_id=user["id"], session_id=st.session_state.get('session_id'), candidate_title=query)
+        except Exception:
+            pass
     result = chain({"question": query, "chat_history": history})
-    history.append((query, result["answer"]))
-    return result["answer"]
+    answer = result["answer"]
+    history.append((query, answer))
+    # Save assistant reply
+    if user:
+        try:
+            save_message_to_supabase(user_id=user["id"], session_id=st.session_state.get('session_id'), role="assistant", content=answer)
+        except Exception:
+            pass
+    return answer
 
 def display_chat_history(chain):
     reply_container = st.container()
@@ -113,7 +334,7 @@ def display_chat_history(chain):
                      help="Aktifkan/Nonaktifkan Text-to-Speech", 
                      use_container_width=True):
             st.session_state['should_speak'] = not st.session_state['should_speak']
-            st.experimental_rerun()
+            st.rerun()
 
     # Tombol Input Suara
     with col3:
@@ -129,7 +350,7 @@ def display_chat_history(chain):
     # Jika ada STT
     if stt_text:
         st.session_state.input_text = stt_text
-        st.experimental_rerun()
+        st.rerun()
 
     # Ambil input user
     user_input = user_input_obj or st.session_state.get("input_text", "")
@@ -147,6 +368,16 @@ def display_chat_history(chain):
             st.session_state['tts_output'] = output
             st.session_state['tts_played'] = False
 
+    # If user just logged in and no local history, try loading from DB
+    if not st.session_state['history']:
+        user = _current_user()
+        if user:
+            past, generated, history = load_history_from_supabase(user_id=user['id'], session_id=st.session_state.get('session_id'))
+            if past or generated:
+                st.session_state['past'] = past or st.session_state['past']
+                st.session_state['generated'] = generated or st.session_state['generated']
+                st.session_state['history'] = history or st.session_state['history']
+
     # Tampilkan Riwayat Chat
     if st.session_state['generated']:
         with reply_container:

app/config.py

@@ -7,3 +7,6 @@ class Config:
     SUPABASE_URL = os.getenv('SUPABASE_URL')
     SUPABASE_KEY = os.getenv('SUPABASE_KEY')
     REPLICATE_API_TOKEN = os.getenv('REPLICATE_API_TOKEN')
+    # Storage/vector configs
+    BUCKET_NAME = os.getenv('BUCKET_NAME', 'pnp-bot-storage-archive')
+    VECTOR_STORE_PREFIX = os.getenv('VECTOR_STORE_PREFIX', 'vector_store')

app/data_loader.py

@@ -1,7 +1,9 @@
 import os
+import streamlit as st
 from app.db import supabase
 from langchain_community.document_loaders import PyPDFLoader, TextLoader, Docx2txtLoader
 
+@st.cache_data(ttl=60, show_spinner=False)
 def list_all_files(bucket_name, limit_per_page=1000):
     all_files = []
     offset = 0

app/rag.py

@@ -0,0 +1,42 @@
+import os
+import streamlit as st
+from langsmith import traceable
+from langchain_community.llms import Replicate
+from langchain.memory import ConversationBufferWindowMemory
+from langchain.chains import ConversationalRetrievalChain
+from langchain_community.document_transformers import LongContextReorder
+from app.prompts import sahabat_prompt
+
+
+def reorder_embedding(docs):
+    """Reorder documents for long context retrieval."""
+    reordering = LongContextReorder()
+    return reordering.transform_documents(docs)
+
+
+@traceable(name="Create RAG Conversational Chain")
+def create_conversational_chain(vector_store):
+    """Create a Conversational Retrieval Chain for RAG with tuned parameters for lower latency."""
+    llm = Replicate(
+        model="fauzi3007/sahabat-ai-replicate:c3fc398f441379bd3fb6a4498950f9302aa75b7a95e76978a689ceb5c4b4bf09",
+        model_kwargs={"temperature": 0.1, "top_p": 0.9, "max_new_tokens": 3000}
+    )
+    memory = ConversationBufferWindowMemory(
+        k=4,
+        memory_key="chat_history",
+        return_messages=True,
+        output_key="answer"
+    )
+    chain = ConversationalRetrievalChain.from_llm(
+        llm,
+        retriever=vector_store.as_retriever(search_type="mmr", search_kwargs={"k": 4, "fetch_k": 20}),
+        combine_docs_chain_kwargs={"prompt": sahabat_prompt},
+        return_source_documents=True,
+        memory=memory,
+    )
+    return chain
+
+
+def get_rag_chain(vector_store):
+    """Return a Conversational Retrieval Chain for external use."""
+    return create_conversational_chain(vector_store)

app/session.py

@@ -0,0 +1,42 @@
+import streamlit as st
+from app.db import supabase
+from app.chat import list_chat_sessions, create_chat_session, ensure_chat_session
+
+
+def restore_user_session_if_needed():
+    """Try to restore Supabase user session into st.session_state['user'] if missing."""
+    if st.session_state.get("user"):
+        return
+    try:
+        current = supabase.auth.get_session()
+        if current and getattr(current, "user", None):
+            u = current.user
+            st.session_state["user"] = {"id": u.id, "email": getattr(u, "email", None)}
+            return
+        if st.session_state.get("sb_session"):
+            toks = st.session_state["sb_session"]
+            if toks.get("access_token") and toks.get("refresh_token"):
+                supabase.auth.set_session(toks["access_token"], toks["refresh_token"])  # may refresh
+                ures = supabase.auth.get_user()
+                user_obj = getattr(ures, "user", None)
+                if user_obj:
+                    st.session_state["user"] = {"id": user_obj.id, "email": getattr(user_obj, "email", None)}
+    except Exception:
+        pass
+
+
+def ensure_active_session(user_id: str):
+    """Ensure st.session_state['session_id'] points to an existing session; create one if needed."""
+    sid = st.session_state.get("session_id")
+    if not sid:
+        sessions = list_chat_sessions(user_id, limit=1)
+        if sessions:
+            sid = sessions[0]["id"]
+        else:
+            sid = create_chat_session(user_id, title="Percakapan Baru")
+        st.session_state["session_id"] = sid
+    try:
+        ensure_chat_session(user_id)  # make sure exists in DB if missing
+    except Exception:
+        pass
+    return st.session_state["session_id"]

app/ui.py

@@ -0,0 +1,128 @@
+import streamlit as st
+from app.chat import (
+    create_chat_session,
+    list_chat_sessions,
+    ensure_chat_session,
+    delete_chat_session,
+    delete_all_chat_sessions,
+)
+from app.db import supabase
+
+
+def render_sidebar_sessions():
+    """Render the sidebar: sessions list/search/pagination, actions, and logout.
+    Assumes st.session_state['user'] exists.
+    """
+    st.sidebar.header("Percakapan")
+    if st.sidebar.button("➕ New Chat", use_container_width=True):
+        uid = st.session_state["user"]["id"]
+        new_sid = create_chat_session(uid, title="Percakapan Baru")
+        st.session_state["session_id"] = new_sid
+        for k in ["history", "generated", "past", "input_text", "tts_output", "tts_played"]:
+            if k in st.session_state:
+                del st.session_state[k]
+        st.rerun()
+
+    # Search and pagination controls
+    search_query = st.sidebar.text_input("Cari sesi", value=st.session_state.get("session_search", ""))
+    st.session_state["session_search"] = search_query
+
+    page_size = st.sidebar.selectbox("Jumlah per halaman", [5, 10, 20, 50], index=1, key="session_page_size")
+    current_page = st.session_state.get("session_page", 0)
+
+    # Fetch sessions
+    try:
+        sessions = list_chat_sessions(st.session_state["user"]["id"], limit=1000)
+    except Exception as e:
+        st.sidebar.error(f"Tidak dapat memuat sesi: {e}")
+        sessions = []
+
+    # Filter by search
+    if search_query:
+        sq = search_query.lower()
+        sessions = [s for s in sessions if sq in (s.get("title") or "").lower() or sq in s.get("id", "").lower()]
+
+    # Pagination
+    total = len(sessions)
+    start = current_page * page_size
+    end = start + page_size
+    page_sessions = sessions[start:end]
+
+    cols = st.sidebar.columns([1, 3, 1])
+    disable_prev = current_page <= 0
+    disable_next = end >= total
+    if cols[0].button("←", disabled=disable_prev):
+        st.session_state["session_page"] = max(0, current_page - 1)
+        st.rerun()
+    cols[1].markdown(f"Halaman {current_page + 1} / {max(1, (total + page_size - 1) // page_size)}")
+    if cols[2].button("→", disabled=disable_next):
+        st.session_state["session_page"] = current_page + 1
+        st.rerun()
+
+    # List sessions with select and delete
+    for s in page_sessions:
+        sid = s["id"]
+        title = s.get("title") or sid
+        row = st.sidebar.container()
+        subcols = row.columns([6, 1])
+        if subcols[0].button(title, key=f"select_{sid}"):
+            st.session_state["session_id"] = sid
+            ensure_chat_session(st.session_state["user"]["id"])  # make sure exists
+            # Clear local caches if switching
+            for k in ["history", "generated", "past"]:
+                if k in st.session_state:
+                    del st.session_state[k]
+            st.rerun()
+        if subcols[1].button("🗑️", key=f"del_{sid}"):
+            try:
+                ok = delete_chat_session(st.session_state["user"]["id"], sid)
+                if ok:
+                    # If deleting active, choose next one or create new
+                    if st.session_state.get("session_id") == sid:
+                        remaining = [x for x in sessions if x["id"] != sid]
+                        if remaining:
+                            st.session_state["session_id"] = remaining[0]["id"]
+                        else:
+                            st.session_state["session_id"] = create_chat_session(st.session_state["user"]["id"], title="Percakapan Baru")
+                    for k in ["history", "generated", "past"]:
+                        if k in st.session_state:
+                            del st.session_state[k]
+                    st.success("Sesi dihapus")
+                    st.rerun()
+                else:
+                    st.error("Gagal menghapus sesi")
+            except Exception as e:
+                st.error(f"Gagal menghapus: {e}")
+
+    st.sidebar.divider()
+    with st.sidebar.expander("Hapus Semua Percakapan", expanded=False):
+        confirm = st.checkbox("Saya yakin ingin menghapus semua percakapan", key="confirm_delete_all")
+        if st.button("Hapus Semua", type="primary", disabled=not confirm):
+            try:
+                ok = delete_all_chat_sessions(st.session_state["user"]["id"])
+                if ok:
+                    st.session_state["session_id"] = create_chat_session(st.session_state["user"]["id"], title="Percakapan Baru")
+                    for k in ["history", "generated", "past"]:
+                        if k in st.session_state:
+                            del st.session_state[k]
+                    st.success("Semua percakapan dihapus")
+                    st.rerun()
+                else:
+                    st.error("Gagal menghapus semua percakapan")
+            except Exception as e:
+                st.error(f"Gagal menghapus semua: {e}")
+
+    st.sidebar.divider()
+    if st.sidebar.button("Logout"):
+        try:
+            supabase.auth.sign_out()
+        except Exception:
+            pass
+        for k in [
+            "user", "history", "generated", "past", "input_text",
+            "tts_output", "tts_played", "vector_store", "session_id", "sb_session"
+        ]:
+            if k in st.session_state:
+                del st.session_state[k]
+        st.success("Anda telah logout")
+        st.rerun()

app/vector_store.py

@@ -0,0 +1,61 @@
+from datetime import datetime
+import streamlit as st
+from typing import Optional
+from app.data_loader import list_all_files
+from app.db import supabase
+from app.document_processor import load_vector_store_from_supabase
+from app.config import Config
+
+# Defaults for bucket/prefix if not present in Config
+BUCKET_NAME = getattr(Config, "BUCKET_NAME", "pnp-bot-storage-archive")
+VECTOR_STORE_PREFIX = getattr(Config, "VECTOR_STORE_PREFIX", "vector_store")
+
+
+def get_latest_data_timestamp_from_files(bucket_name: str) -> float:
+    """Get the latest timestamp from files in a Supabase storage bucket."""
+    files = list_all_files(bucket_name)
+    latest_time = 0.0
+    for file in files:
+        iso_time = file.get("updated_at") or file.get("created_at")
+        if iso_time:
+            try:
+                timestamp = datetime.fromisoformat(iso_time.replace('Z', '+00:00')).timestamp()
+                latest_time = max(latest_time, timestamp)
+            except Exception as e:
+                print(f"Gagal parsing waktu dari {file.get('name')}: {e}")
+    return latest_time
+
+
+def get_supabase_vector_store_timestamp() -> Optional[str]:
+    """Get the latest timestamp of vector store files in the Supabase storage."""
+    try:
+        response = supabase.storage.from_(BUCKET_NAME).list()
+        timestamps = []
+        for file in response:
+            if file["name"].startswith(VECTOR_STORE_PREFIX) and (
+                file["name"].endswith(".faiss") or file["name"].endswith(".pkl")
+            ):
+                timestamps.append(file["updated_at"])
+        if len(timestamps) >= 2:
+            return max(timestamps)
+        return None
+    except Exception as e:
+        print(f"Error getting Supabase timestamp: {e}")
+        return None
+
+
+def vector_store_is_outdated() -> bool:
+    """Check if vector store needs to be updated based on files in Supabase storage."""
+    supabase_timestamp = get_supabase_vector_store_timestamp()
+    if supabase_timestamp is None:
+        return True
+    supabase_time = datetime.fromisoformat(supabase_timestamp.replace("Z", "+00:00")).timestamp()
+    data_time = get_latest_data_timestamp_from_files("pnp-bot-storage")
+
+    return data_time > supabase_time
+
+
+@st.cache_resource(show_spinner=False)
+def get_cached_vector_store():
+    """Cache vector store loading to avoid repeated downloads/deserialization on reruns."""
+    return load_vector_store_from_supabase(supabase, BUCKET_NAME, VECTOR_STORE_PREFIX)

app/workflows.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from app.data_loader import get_data, load_docs
+from app.document_processor import process_documents, save_vector_store_to_supabase
+from app.db import supabase
+from app.config import Config
+import app.vector_store as vs
+import app.rag as rag
+
+BUCKET_NAME = Config.BUCKET_NAME
+VECTOR_STORE_PREFIX = Config.VECTOR_STORE_PREFIX
+
+
+def prepare_vector_store_if_needed(history_len: int):
+    """
+    Orchestrates vector store availability.
+    - If no local history and vector store is outdated: sync data, process, and upload.
+    - Else: load cached vector store from Supabase.
+    Returns a vector_store or None.
+    """
+    vector_store = vs.get_cached_vector_store()
+
+    if history_len == 0:
+        if vs.vector_store_is_outdated():
+            with st.spinner("Memuat dan memproses dokumen..."):
+                get_data()
+                docs = load_docs()
+                if len(docs) > 0:
+                    reordered_docs = rag.reorder_embedding(docs)
+                    vector_store = process_documents(reordered_docs)
+                    with st.spinner("Mengunggah vector store ke Supabase..."):
+                        success = save_vector_store_to_supabase(vector_store, supabase, BUCKET_NAME, VECTOR_STORE_PREFIX)
+                        if success:
+                            print("Vector store berhasil diunggah ke Supabase!")
+                        else:
+                            print("Gagal mengunggah vector store ke Supabase.")
+                else:
+                    print("Folder 'data/' kosong. Chatbot tetap bisa digunakan, tetapi tanpa konteks dokumen.")
+                    vector_store = None
+        else:
+            with st.spinner("Memuat vector store dari Supabase..."):
+                vector_store = vs.get_cached_vector_store()
+                if vector_store:
+                    print("Vector store berhasil dimuat dari Supabase!")
+                else:
+                    print("Gagal memuat vector store dari Supabase.")
+    else:
+        vector_store = st.session_state.get("vector_store") or vs.get_cached_vector_store()
+
+    return vector_store