RAG chat, MiniLM embeddings, M2 fixes

README_PYTHON.md

@@ -0,0 +1,24 @@
+# Python Version
+
+**Gradio does not work reliably with Python 3.13.** Use Python 3.10, 3.11, or 3.12.
+
+## Quick run
+
+```powershell
+.\run.bat
+```
+
+Or manually:
+
+```powershell
+py -3.10 -m pip install -r requirements.txt
+py -3.10 app.py
+```
+
+## Install Python 3.10
+
+If you don't have Python 3.10:
+
+1. Download from https://www.python.org/downloads/release/python-31011/
+2. Run installer, check "Add Python to PATH"
+3. Restart terminal, then run `.\run.bat`

app.py

@@ -1,5 +1,16 @@
 from pathlib import Path
 import shutil
+import sys
+import warnings
+
+# Flush print immediately
+def _log(msg):
+    print(msg, flush=True)
+
+_log("1. Loading env...")
+# Suppress noisy dependency warnings
+warnings.filterwarnings("ignore", message=".*urllib3.*")
+warnings.filterwarnings("ignore", message=".*chardet.*")
 
 from dotenv import load_dotenv
 
@@ -7,14 +18,20 @@ from dotenv import load_dotenv
 load_dotenv(Path(__file__).resolve().parent.parent / ".env")
 load_dotenv(Path(__file__).resolve().parent / ".env")
 
+_log("2. Loading Gradio...")
 from datetime import datetime
 import gradio as gr
+_log("2a. Loading gradio_client...")
 import gradio_client.utils as gradio_client_utils
 
+_log("3. Loading backend...")
 from backend.ingestion_service import ingest_pdf_chunks, ingest_url_chunks, remove_chunks_for_source
 from backend.notebook_service import create_notebook, list_notebooks, rename_notebook, delete_notebook
+from backend.chat_service import load_chat
+from backend.rag_service import rag_chat
 
 import hashlib
+_log("4. Imports done.")
 
 _original_gradio_get_type = gradio_client_utils.get_type
 _original_json_schema_to_python_type = gradio_client_utils._json_schema_to_python_type
@@ -35,43 +52,76 @@ def _patched_json_schema_to_python_type(schema, defs=None):
 gradio_client_utils.get_type = _patched_gradio_get_type
 gradio_client_utils._json_schema_to_python_type = _patched_json_schema_to_python_type
 
-# Theme: adapts to light/dark mode
+# Theme: adapts to light/dark mode (use default font to avoid network fetch on startup)
 theme = gr.themes.Soft(
     primary_hue="blue",
     secondary_hue="slate",
-    font=gr.themes.GoogleFont("Inter"),
 )
 
 CUSTOM_CSS = """
-.container { max-width: 720px; margin: 0 auto; padding: 0 24px; }
-.login-center { display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 12px; padding: 24px 0; }
-.login-center .login-btn-wrap { display: flex; justify-content: center; width: 100%; }
-.login-center .login-btn-wrap button { display: inline-flex; align-items: center; gap: 8px; }
-.hero { font-size: 1.5rem; font-weight: 600; color: #1e293b; margin-bottom: 8px; }
-.sub { font-size: 0.875rem; color: #64748b; margin-bottom: 24px; }
-.nb-row { display: flex; align-items: center; gap: 12px; padding: 10px 0; border-bottom: 1px solid #e2e8f0; }
-.nb-row:last-child { border-bottom: none; }
-.gr-button { min-height: 36px !important; padding: 0 16px !important; font-weight: 500 !important; border-radius: 8px !important; }
-.gr-input { min-height: 40px !important; border-radius: 8px !important; }
-.status { font-size: 0.875rem; color: #64748b; margin-top: 16px; padding: 12px 16px; background: #f8fafc; border-radius: 8px; }
+.gradio-container { max-width: 1000px !important; margin: 0 auto !important; }
+.container { max-width: 1000px; margin: 0 auto; padding: 0 24px; }
+
+.header-bar { padding: 12px 0; border-bottom: 1px solid #e2e8f0; margin-bottom: 24px; display: flex !important; justify-content: space-between !important; align-items: center !important; white-space: nowrap; }
+.login-center { display: flex; justify-content: center; width: 100%; }
+#auth-text { white-space: nowrap; margin: 8px 0 16px 0; font-size: 0.95rem; opacity: 0.9; }
+.gr-button { padding: 14px 28px !important; font-size: 0.9rem !important; border-radius: 12px !important; white-space: nowrap !important; width: auto !important; }
+.gr-button[aria-label*="Logout"] { min-width: auto !important; display: inline-flex !important; align-items: center !important; justify-content: center !important; }
+.header-bar .gr-button { padding-left: 40px !important; padding-right: 40px !important; min-width: 220px !important; font-size: 0.8rem !important; }
+.dark .header-bar { border-bottom: 1px solid #334155; }
+
+.hero-section { margin-bottom: 16px; }
+.login-container { padding: 12px 0; }
+.create-strip { padding: 18px; border-radius: 16px; }
+.create-row { display: flex !important; align-items: center !important; gap: 16px !important; }
+.create-label { white-space: nowrap; font-size: 0.95rem; margin: 0; min-width: 180px; }
+.create-row .gr-textbox { flex: 1 !important; }
+.create-row .gr-textbox textarea,
+.create-row .gr-textbox input { border-radius: 10px !important; }
+.create-row .gr-button { border-radius: 10px !important; padding: 10px 20px !important; }
+.hero-title { font-size: 2rem; font-weight: 700; color: #1e293b; margin: 0 0 8px 0; }
+.hero-sub { font-size: 1rem; color: #64748b; margin: 0; line-height: 1.5; }
+
+.section-card { padding: 24px; border-radius: 16px; background: #f8fafc; margin-bottom: 24px; box-shadow: 0 2px 8px rgba(0,0,0,0.06); }
+.notebook-card { padding: 14px 20px; border-radius: 12px; background: #fff; margin-bottom: 8px; border: 1px solid #e2e8f0; display: flex; align-items: center; gap: 12px; transition: background 0.15s ease; }
+.notebook-card:hover { background: #f8fafc; }
+
+.section-title { font-size: 1.125rem; font-weight: 600; color: #1e293b; margin: 0 0 16px 0; }
+.section-row { display: flex !important; align-items: center !important; gap: 16px !important; margin-bottom: 12px; }
+.section-row .gr-textbox { flex: 1 !important; }
+.section-row .gr-button { border-radius: 10px !important; padding: 10px 20px !important; }
+
+.status { font-size: 0.875rem; color: #64748b; margin-top: 16px; padding: 12px 16px; background: #f1f5f9; border-radius: 12px; }
+
 @media (prefers-color-scheme: dark) {
-  .hero { color: #f1f5f9 !important; }
-  .sub { color: #94a3b8 !important; }
-  .nb-row { border-color: #334155 !important; }
-  .status { color: #94a3b8 !important; background: #1e293b !important; }
+  .hero-title { color: #f1f5f9 !important; }
+  .hero-sub { color: #94a3b8 !important; }
+  .section-card { background: #1e293b !important; box-shadow: 0 2px 8px rgba(0,0,0,0.3); }
+  .section-title { color: #f1f5f9 !important; }
+  .notebook-card { background: #334155 !important; border-color: #475569; }
+  .notebook-card:hover { background: #475569 !important; }
+  .status { color: #94a3b8 !important; background: #334155 !important; }
 }
-.dark .hero { color: #f1f5f9 !important; }
-.dark .sub { color: #94a3b8 !important; }
-.dark .nb-row { border-color: #334155 !important; }
-.dark .status { color: #94a3b8 !important; background: #1e293b !important; }
+.dark .hero-title { color: #f1f5f9 !important; }
+.dark .hero-sub { color: #94a3b8 !important; }
+.dark .section-card { background: #1e293b !important; }
+.dark .section-title { color: #f1f5f9 !important; }
+.dark .notebook-card { background: #334155 !important; border-color: #475569; }
+.dark .notebook-card:hover { background: #475569 !important; }
+.dark .status { color: #94a3b8 !important; background: #334155 !important; }
 """
 
-MAX_NOTEBOOKS = 20
-
-
 def _user_id(profile: gr.OAuthProfile | None) -> str | None:
     """Extract user_id from HF OAuth profile. None if not logged in."""
-    return profile.name if profile else None
+    if not profile:
+        return None
+    return (
+        getattr(profile, "id", None)
+        or getattr(profile, "sub", None)
+        or getattr(profile, "preferred_username", None)
+        or getattr(profile, "username", None)
+        or getattr(profile, "name", None)
+    )
 
 
 def _get_notebooks(user_id: str | None):
@@ -85,70 +135,59 @@ def _safe_create(new_name, state, selected_id, profile: gr.OAuthProfile | None):
     try:
         user_id = _user_id(profile)
         if not user_id:
-            return gr.skip(), gr.skip(), gr.skip(), "Please sign in with Hugging Face", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return gr.skip(), gr.skip(), gr.skip(), "Please sign in with Hugging Face"
         name = (new_name or "").strip() or "Untitled Notebook"
         nb = create_notebook(user_id, name)
         if nb:
             notebooks = _get_notebooks(user_id)
-            state = [(n["notebook_id"], n["name"]) for n in notebooks]
-            updates = _build_row_updates(notebooks)
-            new_selected = nb["notebook_id"]
+            new_state = [(n["notebook_id"], n["name"]) for n in notebooks]
             status = f"Created: {nb['name']}"
-            return "", state, new_selected, status, *updates
-        return gr.skip(), gr.skip(), gr.skip(), "Failed to create", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return "", new_state, nb["notebook_id"], status
+        return gr.skip(), gr.skip(), gr.skip(), "Failed to create"
     except Exception as e:
-        return gr.skip(), gr.skip(), gr.skip(), f"Error: {e}", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+        return gr.skip(), gr.skip(), gr.skip(), f"Error: {e}"
 
 
 def _safe_rename(idx, new_name, state, selected_id, profile: gr.OAuthProfile | None):
     """Rename notebook at index."""
     try:
         if idx is None or idx < 0 or idx >= len(state):
-            return gr.skip(), gr.skip(), gr.skip(), *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return gr.skip(), gr.skip(), "Invalid selection"
         nb_id, _ = state[idx]
         name = (new_name or "").strip()
         if not name:
-            return gr.skip(), gr.skip(), gr.skip(), "Enter a name.", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return gr.skip(), gr.skip(), "Enter a name."
         user_id = _user_id(profile)
         if not user_id:
-            return gr.skip(), gr.skip(), gr.skip(), "Please sign in", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return gr.skip(), gr.skip(), "Please sign in"
         ok = rename_notebook(user_id, nb_id, name)
         if ok:
             notebooks = _get_notebooks(user_id)
-            state = [(n["notebook_id"], n["name"]) for n in notebooks]
-            updates = _build_row_updates(notebooks)
-            return state, selected_id, f"Renamed to: {name}", *updates
-        return gr.skip(), gr.skip(), gr.skip(), "Failed to rename", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            new_state = [(n["notebook_id"], n["name"]) for n in notebooks]
+            return new_state, selected_id, f"Renamed to: {name}"
+        return gr.skip(), gr.skip(), "Failed to rename"
     except Exception as e:
-        return gr.skip(), gr.skip(), gr.skip(), f"Error: {e}", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+        return gr.skip(), gr.skip(), f"Error: {e}"
 
 
 def _safe_delete(idx, state, selected_id, profile: gr.OAuthProfile | None):
     """Delete notebook at index."""
     try:
         if idx is None or idx < 0 or idx >= len(state):
-            return gr.skip(), gr.skip(), gr.skip(), *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return gr.skip(), gr.skip(), "Invalid selection"
         nb_id, _ = state[idx]
         user_id = _user_id(profile)
         if not user_id:
-            return gr.skip(), gr.skip(), gr.skip(), "Please sign in", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return gr.skip(), gr.skip(), "Please sign in"
         ok = delete_notebook(user_id, nb_id)
         if ok:
             notebooks = _get_notebooks(user_id)
-            state = [(n["notebook_id"], n["name"]) for n in notebooks]
-            updates = _build_row_updates(notebooks)
+            new_state = [(n["notebook_id"], n["name"]) for n in notebooks]
             new_selected = notebooks[0]["notebook_id"] if notebooks else None
-            return state, new_selected, "Notebook deleted", *updates
-        return gr.skip(), gr.skip(), gr.skip(), "Failed to delete", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+            return new_state, new_selected, "Notebook deleted"
+        return gr.skip(), gr.skip(), "Failed to delete"
     except Exception as e:
-        return gr.skip(), gr.skip(), gr.skip(), f"Error: {e}", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
-
-
-def _select_notebook(idx, state):
-    """Set selected notebook when user interacts with a row."""
-    if idx is None or idx < 0 or idx >= len(state):
-        return gr.skip()
-    return state[idx][0]
+        return gr.skip(), gr.skip(), f"Error: {e}"
 
 
 def _initial_load(profile: gr.OAuthProfile | None):
@@ -157,9 +196,10 @@ def _initial_load(profile: gr.OAuthProfile | None):
     notebooks = _get_notebooks(user_id)
     state = [(n["notebook_id"], n["name"]) for n in notebooks]
     selected = notebooks[0]["notebook_id"] if notebooks else None
-    updates = _build_row_updates(notebooks)
     status = f"Signed in as {user_id}" if user_id else "Sign in with Hugging Face to manage notebooks."
-    return state, selected, status, *updates
+    auth_update = f"You are logged in as {getattr(profile, 'name', None) or user_id} ({_user_id(profile)})" if user_id else ""
+    auth_row_visible = bool(user_id)
+    return state, selected, status, auth_update, gr.update(visible=auth_row_visible), gr.update(visible=bool(user_id)), gr.update(visible=not bool(user_id))
 
 
 def _safe_upload_pdfs(files, selected_id, profile: gr.OAuthProfile | None):
@@ -310,16 +350,6 @@ def _safe_remove_url(url, selected_id, profile: gr.OAuthProfile | None):
 
 
 
-def _build_row_updates(notebooks):
-    """Return gr.update values for each row: visibility, then text value."""
-    out = []
-    for i in range(MAX_NOTEBOOKS):
-        visible = i < len(notebooks)
-        name = notebooks[i]["name"] if visible else ""
-        out.append(gr.update(visible=visible))
-        out.append(gr.update(value=name, visible=visible))
-    return out
-
 # ── Upload Handler Functions ──────────────────────────────────
 def _do_upload(text_content, title, notebook_id, profile: gr.OAuthProfile | None):
     """Handle direct text input and ingestion."""
@@ -385,90 +415,218 @@ def _load_sources(notebook_id, profile: gr.OAuthProfile | None):
     sources = list_sources(notebook_id)
     return _format_sources(sources)
 
+
+def _chat_history_to_pairs(messages: list[dict]) -> list[tuple[str, str]]:
+    """Convert load_chat output to Gradio Chatbot format [(user, assistant), ...]."""
+    pairs = []
+    i = 0
+    while i < len(messages):
+        m = messages[i]
+        if m["role"] == "user":
+            user_content = m["content"] or ""
+            asst_content = ""
+            if i + 1 < len(messages) and messages[i + 1]["role"] == "assistant":
+                asst_content = messages[i + 1]["content"] or ""
+                i += 1
+            pairs.append((user_content, asst_content))
+        i += 1
+    return pairs
+
+
+def _load_chat_history(notebook_id) -> tuple[list[tuple[str, str]], list[tuple[str, str]]]:
+    """Load chat for notebook. Returns (history_pairs, history_pairs) for State and Chatbot."""
+    if not notebook_id:
+        return [], []
+    messages = load_chat(notebook_id)
+    pairs = _chat_history_to_pairs(messages)
+    return pairs, pairs
+
+
+def _on_chat_submit(query, notebook_id, chat_history, profile: gr.OAuthProfile | None):
+    """Handle chat submit: call RAG, return updated history."""
+    if not notebook_id:
+        return "", chat_history, "Select a notebook first."
+    if not query or not query.strip():
+        return "", chat_history, "Enter a message."
+    user_id = _user_id(profile)
+    if not user_id:
+        return "", chat_history, "Please sign in first."
+    try:
+        answer, updated = rag_chat(notebook_id, query.strip(), chat_history)
+        return "", updated, ""
+    except Exception as e:
+        return "", chat_history, f"Error: {e}"
+
 with gr.Blocks(
     title="NotebookLM Clone - Notebooks",
     theme=theme,
     css=CUSTOM_CSS,
 ) as demo:
-    gr.HTML('<div class="container"><p class="hero">Notebook Manager</p><p class="sub">Create notebook below, then manage with Rename and Delete</p></div>')
-
-    with gr.Row(elem_classes=["login-center"]):
-        gr.Markdown("**Sign in with Hugging Face to access your notebooks**")
-        with gr.Row(elem_classes=["login-btn-wrap"]):
-            login_btn = gr.LoginButton(value="🤗 Login with Hugging Face", size="lg")
-
-    nb_state = gr.State([])
-    selected_notebook_id = gr.State(None)
-
-    # Create section: text box + Create button
-    with gr.Row():
-        create_txt = gr.Textbox(
-            label="Create notebook",
-            placeholder="Enter new notebook name",
-            value="",
-            scale=3,
-        )
-        create_btn = gr.Button("Create", variant="primary", scale=1)
-
-    with gr.Row():
-        pdf_upload_btn = gr.UploadButton(
-            "Upload PDFs",
-            file_types=[".pdf"],
-            file_count="multiple",
-            type="filepath",
-            variant="secondary",
-        )
-
-    with gr.Row():
-        uploaded_pdf_dd = gr.Dropdown(
-            label="Uploaded PDFs",
-            choices=[],
-            value=None,
-            scale=3,
-            allow_custom_value=False,
-        )
-        remove_pdf_btn = gr.Button("Remove selected PDF", variant="stop", scale=1)
-
-    with gr.Row():
-        url_txt = gr.Textbox(
-            label="Ingest web URL",
-            placeholder="https://example.com",
-            value="",
-            scale=3,
-        )
-        ingest_url_btn = gr.Button("Ingest URL", variant="primary", scale=1)
-        remove_url_btn = gr.Button("Delete URL", variant="stop", scale=1)
-
-    gr.Markdown("---")
-    gr.Markdown("**Your notebooks** (selected notebook used for chat/ingestion)")
-
-    # Rows: each notebook has [name] [Rename] [Delete]
-    row_components = []
-    row_outputs = []
-    for i in range(MAX_NOTEBOOKS):
-        with gr.Row(visible=False) as row:
-            name_txt = gr.Textbox(
-                value="",
+    with gr.Row(elem_classes=["header-bar"]):
+        gr.Markdown("### 📓 NotebookLM Clone")
+        login_btn = gr.LoginButton(value="🤗 Login with Hugging Face", size="lg")
+
+    with gr.Row(visible=False) as auth_info_row:
+        auth_text = gr.Markdown("", elem_id="auth-text")
+
+    gr.HTML("""
+    <div class="container hero-section">
+        <h1 class="hero-title">📓 NotebookLM Clone</h1>
+        <p class="hero-sub">Chat with your documents. Generate reports, quizzes, and podcasts with citations.</p>
+    </div>
+    """)
+
+    with gr.Column(visible=False, elem_classes=["login-container"]) as login_container:
+        gr.Markdown("**Sign in with Hugging Face to access your notebooks.**", elem_classes=["login-center"])
+
+    with gr.Column(visible=False) as app_content:
+        nb_state = gr.State([])
+        selected_notebook_id = gr.State(None)
+
+        with gr.Group(elem_classes=["create-strip"]):
+            with gr.Row(elem_classes=["create-row"]):
+                gr.Markdown("Create new notebook", elem_classes=["create-label"])
+                create_txt = gr.Textbox(
+                    placeholder="Enter new notebook name",
+                    show_label=False,
+                    container=False,
+                    value="",
+                )
+                create_btn = gr.Button("Create", variant="primary", size="sm")
+
+        with gr.Group(elem_classes=["section-card"]):
+            gr.Markdown("**Sources**", elem_classes=["section-title"])
+            gr.Markdown("*Upload PDFs, ingest URLs, or add text to your selected notebook*")
+            with gr.Row(elem_classes=["section-row"]):
+                pdf_upload_btn = gr.UploadButton(
+                    "Upload PDFs",
+                    file_types=[".pdf"],
+                    file_count="multiple",
+                    type="filepath",
+                    variant="secondary",
+                )
+            with gr.Row(elem_classes=["section-row"]):
+                uploaded_pdf_dd = gr.Dropdown(
+                    label="Uploaded PDFs",
+                    choices=[],
+                    value=None,
+                    scale=3,
+                    allow_custom_value=False,
+                )
+                remove_pdf_btn = gr.Button("Remove selected PDF", variant="stop", scale=1)
+            with gr.Row(elem_classes=["section-row"]):
+                url_txt = gr.Textbox(
+                    label="Ingest web URL",
+                    placeholder="https://example.com",
+                    value="",
+                    scale=3,
+                )
+                ingest_url_btn = gr.Button("Ingest URL", variant="primary", scale=1)
+                remove_url_btn = gr.Button("Delete URL", variant="stop", scale=1)
+
+        gr.HTML("<br>")
+        gr.Markdown("**Your Notebooks**", elem_classes=["section-title"])
+        gr.Markdown("*Selected notebook is used for chat and ingestion*", elem_id="sub-hint")
+        gr.HTML("<br>")
+
+        status = gr.Markdown("Sign in with Hugging Face to manage notebooks.", elem_classes=["status"])
+
+        @gr.render(inputs=[nb_state])
+        def render_notebooks(state):
+            if not state:
+                gr.Markdown("No notebooks yet. Create one to get started.")
+            else:
+                for i, (nb_id, name) in enumerate(state):
+                    idx = i
+                    with gr.Row(elem_classes=["notebook-card"]):
+                        name_txt = gr.Textbox(value=name, show_label=False, scale=4, min_width=240, key=f"nb-name-{nb_id}")
+                        select_btn = gr.Button("Select", variant="primary", scale=1, min_width=80, size="sm")
+                        rename_btn = gr.Button("Rename", variant="secondary", scale=1, min_width=80, size="sm")
+                        delete_btn = gr.Button("Delete", variant="secondary", scale=1, min_width=80, size="sm")
+
+                        def on_select(nb_id=nb_id):
+                            return nb_id
+
+                        def on_select_status():
+                            return "Selected notebook updated. Use this for chat/ingestion."
+
+                        select_btn.click(
+                            on_select,
+                            inputs=None,
+                            outputs=[selected_notebook_id],
+                        ).then(on_select_status, None, [status]).then(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd])
+
+                        rename_btn.click(
+                            _safe_rename,
+                            inputs=[gr.State(idx), name_txt, nb_state, selected_notebook_id],
+                            outputs=[nb_state, selected_notebook_id, status],
+                            api_name=False,
+                        )
+
+                        delete_btn.click(
+                            _safe_delete,
+                            inputs=[gr.State(idx), nb_state, selected_notebook_id],
+                            outputs=[nb_state, selected_notebook_id, status],
+                            api_name=False,
+                        ).then(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd])
+
+        gr.HTML("<br>")
+
+        with gr.Group(elem_classes=["section-card"]):
+            gr.Markdown("**Add Text**", elem_classes=["section-title"])
+            gr.Markdown("*Select a notebook above, then paste or type your text*")
+            with gr.Row():
+                txt_title = gr.Textbox(
+                    label="Title",
+                    placeholder="Give this text a name (e.g. 'Lecture Notes Week 1')",
+                    scale=1,
+                )
+            txt_input = gr.Textbox(
+                label="Text Content",
+                placeholder="Paste or type your text here...",
+                lines=10,
+            )
+            submit_btn = gr.Button("Save & Process", variant="primary")
+            upload_status = gr.Markdown("", elem_classes=["status"])
+            sources_display = gr.Markdown("")
+
+        with gr.Group(elem_classes=["section-card"]):
+            gr.Markdown("**Chat**", elem_classes=["section-title"])
+            gr.Markdown("*Ask questions about your notebook sources. Answers are grounded in retrieved chunks with citations.*")
+            chat_history_state = gr.State([])
+            chatbot = gr.Chatbot(label="Chat history", height=400)
+            chat_input = gr.Textbox(
+                label="Message",
+                placeholder="Ask a question about your sources...",
                 show_label=False,
-                scale=3,
-                min_width=200,
+                lines=2,
             )
-            rename_btn = gr.Button("Rename", scale=1, min_width=80)
-            delete_btn = gr.Button("Delete", variant="stop", scale=1, min_width=80)
-            select_btn = gr.Button("Select", scale=1, min_width=70)
-            row_components.append({"row": row, "name": name_txt, "rename": rename_btn, "delete": delete_btn, "select": select_btn})
-            row_outputs.extend([row, name_txt])
+            chat_submit_btn = gr.Button("Send", variant="primary")
+            chat_status = gr.Markdown("", elem_classes=["status"])
 
-    status = gr.Markdown("Sign in with Hugging Face to manage notebooks.", elem_classes=["status"])
-
-    demo.load(_initial_load, inputs=None, outputs=[nb_state, selected_notebook_id, status] + row_outputs, api_name=False)
+    demo.load(
+        _initial_load,
+        inputs=None,
+        outputs=[nb_state, selected_notebook_id, status, auth_text, auth_info_row, app_content, login_container],
+        api_name=False,
+    )
     demo.load(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd], api_name=False)
 
-    # Create button
+    def _on_notebook_select_for_chat(notebook_id):
+        hist, _ = _load_chat_history(notebook_id)
+        return hist, hist
+
+    selected_notebook_id.change(
+        _on_notebook_select_for_chat,
+        inputs=[selected_notebook_id],
+        outputs=[chat_history_state, chatbot],
+        api_name=False,
+    )
+
     create_btn.click(
         _safe_create,
         inputs=[create_txt, nb_state, selected_notebook_id],
-        outputs=[create_txt, nb_state, selected_notebook_id, status] + row_outputs,
+        outputs=[create_txt, nb_state, selected_notebook_id, status],
         api_name=False,
     ).then(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd])
 
@@ -500,57 +658,6 @@ with gr.Blocks(
         api_name=False,
     ).then(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd])
 
-    # Per-row: Rename, Delete, Select (profile injected by Gradio for OAuth)
-    for i in range(MAX_NOTEBOOKS):
-        rename_btn = row_components[i]["rename"]
-        delete_btn = row_components[i]["delete"]
-        select_btn = row_components[i]["select"]
-        name_txt = row_components[i]["name"]
-
-        rename_btn.click(
-            _safe_rename,
-            inputs=[gr.State(i), name_txt, nb_state, selected_notebook_id],
-            outputs=[nb_state, selected_notebook_id, status] + row_outputs,
-            api_name=False,
-        )
-        delete_btn.click(
-            _safe_delete,
-            inputs=[gr.State(i), nb_state, selected_notebook_id],
-            outputs=[nb_state, selected_notebook_id, status] + row_outputs,
-            api_name=False,
-        ).then(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd])
-        def _on_select():
-            return "Selected notebook updated. Use this for chat/ingestion."
-        select_btn.click(
-            _select_notebook,
-            inputs=[gr.State(i), nb_state],
-            outputs=[selected_notebook_id],
-            api_name=False,
-        ).then(_on_select, None, [status]).then(_list_uploaded_pdfs, inputs=[selected_notebook_id], outputs=[uploaded_pdf_dd])
-
-    # ── Text Input Section ────────────────────────────────────
-    gr.Markdown("---")
-    gr.Markdown("## Add Text")
-    gr.Markdown("Select a notebook above, then paste or type your text.")
-
-    with gr.Row():
-        txt_title = gr.Textbox(
-            label="Title",
-            placeholder="Give this text a name (e.g. 'Lecture Notes Week 1')",
-            scale=1,
-        )
-
-    txt_input = gr.Textbox(
-        label="Text Content",
-        placeholder="Paste or type your text here...",
-        lines=10,
-    )
-
-    submit_btn = gr.Button("Save & Process", variant="primary")
-
-    upload_status = gr.Markdown("", elem_classes=["status"])
-    sources_display = gr.Markdown("")
-
     submit_btn.click(
         _do_upload,
         inputs=[txt_input, txt_title, selected_notebook_id],
@@ -563,4 +670,17 @@ with gr.Blocks(
         outputs=[sources_display],
     )
 
-demo.launch()
+    chat_submit_btn.click(
+        _on_chat_submit,
+        inputs=[chat_input, selected_notebook_id, chat_history_state],
+        outputs=[chat_input, chat_history_state, chat_status],
+        api_name=False,
+    ).then(
+        lambda h: (h, h),
+        inputs=[chat_history_state],
+        outputs=[chat_history_state, chatbot],
+    )
+
+if __name__ == "__main__":
+    _log("5. Launching Gradio...")
+    demo.launch()

backend/embedding_service.py

@@ -0,0 +1,30 @@
+"""Shared embedding service - 384-dim vectors for RAG (ingestion + retrieval). Uses MiniLM for low memory."""
+
+from sentence_transformers import SentenceTransformer
+
+_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+_model = None
+
+
+def _get_model() -> SentenceTransformer:
+    """Lazy-load the embedding model."""
+    global _model
+    if _model is None:
+        _model = SentenceTransformer(_MODEL_NAME)
+    return _model
+
+
+def encode(texts: list[str], task: str = "search_document") -> list[list[float]]:
+    """
+    Embed texts. Returns list of 384-dim vectors.
+
+    Args:
+        texts: List of strings to embed.
+        task: Unused (MiniLM doesn't need prefix); kept for API compatibility.
+    """
+    if not texts:
+        return []
+
+    model = _get_model()
+    embeddings = model.encode(texts, show_progress_bar=False)
+    return [e.tolist() for e in embeddings]

backend/ingestion_service.py

@@ -1,10 +1,11 @@
-"""PDF ingestion for RAG: extract text, chunk, and persist to chunks table."""
+"""PDF ingestion for RAG: extract text, chunk, embed, and persist to chunks table."""
 
 from pathlib import Path
 
 from pypdf import PdfReader
 
 from backend.db import supabase
+from backend.embedding_service import encode as embed_texts
 
 import requests
 from bs4 import BeautifulSoup
@@ -39,7 +40,7 @@ def _chunk_text(text: str, chunk_size: int = DEFAULT_CHUNK_SIZE, overlap: int =
 
 
 def ingest_pdf_chunks(notebook_id: str, source_id: str, pdf_path: Path) -> int:
-    """Extract and store chunks for a single PDF. Returns number of chunks inserted."""
+    """Extract, embed, and store chunks for a single PDF. Returns number of chunks inserted."""
     text = _extract_pdf_text(pdf_path)
     chunks = _chunk_text(text)
 
@@ -48,11 +49,14 @@ def ingest_pdf_chunks(notebook_id: str, source_id: str, pdf_path: Path) -> int:
     if not chunks:
         return 0
 
+    embeddings = embed_texts(chunks, task="search_document")
+
     rows = [
         {
             "notebook_id": notebook_id,
             "source_id": source_id,
             "content": chunk,
+            "embedding": embeddings[index],
             "metadata": {
                 "file_name": source_id,
                 "file_path": str(pdf_path),
@@ -88,6 +92,7 @@ def _extract_url_text(url: str) -> str:
     return " ".join(text.split()).strip()
 
 def ingest_url_chunks(notebook_id: str, source_id: str, url: str) -> int:
+    """Extract, embed, and store chunks for a URL. Returns number of chunks inserted."""
     text = _extract_url_text(url)
     chunks = _chunk_text(text)
 
@@ -96,11 +101,14 @@ def ingest_url_chunks(notebook_id: str, source_id: str, url: str) -> int:
     if not chunks:
         return 0
 
+    embeddings = embed_texts(chunks, task="search_document")
+
     rows = [
         {
             "notebook_id": notebook_id,
             "source_id": source_id,
             "content": chunk,
+            "embedding": embeddings[index],
             "metadata": {
                 "url": url,
                 "chunk_index": index,

backend/ingestion_txt.py

@@ -10,12 +10,7 @@ from uuid import uuid4
 
 from backend.db import supabase
 from backend.storage import save_file, get_sources_path
-
-import os
-from sentence_transformers import SentenceTransformer
-
-# Load model once at module level (not on every call)
-_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+from backend.embedding_service import encode as embed_texts
 # ── Constants ────────────────────────────────────────────────
 
 MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
@@ -116,16 +111,14 @@ def chunk_text(text: str, source_id: str, notebook_id: str, filename: str = "")
 # ── Embed + Store ─────────────────────────────────────────────
 def embed_and_store_chunks(chunks: list[dict]) -> None:
     """
-    Embed chunks using sentence-transformers and store in pgvector.
+    Embed chunks using shared 1536-dim model and store in pgvector.
     """
     if not chunks:
         return
 
-    # Embed all chunks in one batch
     texts = [c["content"] for c in chunks]
-    embeddings = _model.encode(texts, show_progress_bar=False)
+    embeddings = embed_texts(texts, task="search_document")
 
-    # Build rows for Supabase insert
     rows = []
     for chunk, embedding in zip(chunks, embeddings):
         rows.append({
@@ -133,7 +126,7 @@ def embed_and_store_chunks(chunks: list[dict]) -> None:
             "source_id": str(chunk["source_id"]),
             "notebook_id": str(chunk["notebook_id"]),
             "content": chunk["content"],
-            "embedding": embedding.tolist(),
+            "embedding": embedding,
             "metadata": chunk["metadata"]
         })
 

backend/rag_service.py

@@ -0,0 +1,90 @@
+"""RAG chat service - retrieve chunks, call LLM, persist messages."""
+
+import os
+import re
+
+from huggingface_hub import InferenceClient
+
+from backend.chat_service import save_message, load_chat
+from backend.retrieval_service import retrieve_chunks
+
+MAX_HISTORY_MESSAGES = 20
+DEFAULT_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
+TOP_K = 5
+
+_client: InferenceClient | None = None
+
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        token = os.getenv("HF_TOKEN")
+        _client = InferenceClient(token=token)
+    return _client
+
+
+def _validate_citations(text: str, num_chunks: int) -> str:
+    """Strip or fix citation numbers [N] where N > num_chunks."""
+    if num_chunks <= 0:
+        return text
+
+    def replace_citation(match):
+        n = int(match.group(1))
+        if 1 <= n <= num_chunks:
+            return match.group(0)
+        return ""
+
+    return re.sub(r"\[(\d+)\]", replace_citation, text)
+
+
+def rag_chat(notebook_id: str, query: str, chat_history: list) -> tuple[str, list]:
+    """
+    RAG chat: retrieve chunks, build prompt, call LLM, persist, return answer and updated history.
+
+    chat_history: list of [user_msg, assistant_msg] pairs (Gradio Chatbot format).
+    Returns: (assistant_reply, updated_history).
+    """
+    save_message(notebook_id, "user", query)
+
+    chunks = retrieve_chunks(notebook_id, query, top_k=TOP_K)
+
+    context_parts = []
+    for i, c in enumerate(chunks, 1):
+        context_parts.append(f"[{i}] {c['content']}")
+    context = "\n\n".join(context_parts) if context_parts else "(No relevant sources found.)"
+
+    system_content = (
+        "You are a helpful assistant. Answer ONLY from the provided context. "
+        "Cite sources using [1], [2], etc. corresponding to the numbered passages. "
+        "If the answer is not in the context, say so clearly.\n\n"
+        f"Context:\n{context}"
+    )
+
+    # Truncate history to last MAX_HISTORY_MESSAGES (pairs -> 2*N messages)
+    max_pairs = MAX_HISTORY_MESSAGES // 2
+    truncated = chat_history[-max_pairs:] if len(chat_history) > max_pairs else chat_history
+
+    messages = [{"role": "system", "content": system_content}]
+    for user_msg, asst_msg in truncated:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if asst_msg:
+            messages.append({"role": "assistant", "content": asst_msg})
+    messages.append({"role": "user", "content": query})
+
+    try:
+        client = _get_client()
+        response = client.chat_completion(
+            messages=messages,
+            model=DEFAULT_MODEL,
+            max_tokens=512,
+        )
+        raw_answer = response.choices[0].message.content
+        answer = _validate_citations(raw_answer, len(chunks))
+    except Exception as e:
+        answer = f"Error calling model: {e}"
+
+    save_message(notebook_id, "assistant", answer)
+
+    updated_history = chat_history + [[query, answer]]
+    return answer, updated_history

backend/retrieval_service.py

@@ -0,0 +1,39 @@
+"""Retrieval service - vector similarity search for RAG."""
+
+from backend.db import supabase
+from backend.embedding_service import encode
+
+
+def retrieve_chunks(notebook_id: str, query: str, top_k: int = 5) -> list[dict]:
+    """
+    Retrieve top-k chunks for a query, filtered by notebook_id.
+
+    Returns list of dicts with keys: id, content, metadata, similarity.
+    """
+    if not query or not query.strip():
+        return []
+
+    query_embedding = encode([query.strip()], task="search_query")[0]
+
+    try:
+        result = supabase.rpc(
+            "match_chunks",
+            {
+                "query_embedding": query_embedding,
+                "match_count": top_k,
+                "p_notebook_id": notebook_id,
+            },
+        ).execute()
+
+        rows = result.data or []
+        return [
+            {
+                "id": str(r["id"]),
+                "content": r["content"],
+                "metadata": r.get("metadata") or {},
+                "similarity": float(r.get("similarity", 0)),
+            }
+            for r in rows
+        ]
+    except Exception:
+        return []

db/migrate_to_384.sql

@@ -0,0 +1,35 @@
+-- Migration: Switch from 1536-dim to 384-dim embeddings (MiniLM)
+-- Run this in Supabase SQL Editor if you already have the chunks table with vector(1536)
+
+-- 1. Drop the ivfflat index (required before altering column)
+drop index if exists idx_chunks_embedding;
+
+-- 2. Clear existing chunks (old 1536-dim embeddings are incompatible)
+truncate table chunks;
+
+-- 3. Replace embedding column with 384-dim version
+alter table chunks drop column embedding;
+alter table chunks add column embedding vector(384);
+
+-- 4. Recreate the ivfflat index (run AFTER ingesting new PDF/TXT - requires rows)
+-- create index if not exists idx_chunks_embedding on chunks using ivfflat (embedding vector_cosine_ops) with (lists = 100);
+
+-- 5. Update match_chunks RPC
+create or replace function match_chunks(
+  query_embedding vector(384),
+  match_count int,
+  p_notebook_id uuid
+)
+returns table (id uuid, content text, metadata jsonb, similarity float)
+language plpgsql as $$
+begin
+  return query
+  select c.id, c.content, c.metadata,
+         1 - (c.embedding <=> query_embedding) as similarity
+  from chunks c
+  where c.notebook_id = p_notebook_id
+    and c.embedding is not null
+  order by c.embedding <=> query_embedding
+  limit match_count;
+end;
+$$;

db/schema.sql

@@ -33,19 +33,40 @@ create index if not exists idx_artifacts_notebook_id on artifacts(notebook_id);
 -- pgvector extension for embeddings
 create extension if not exists vector;
 
--- chunks with embeddings (for RAG)
+-- chunks with embeddings (for RAG) - 384 dims for MiniLM
 create table if not exists chunks (
   id uuid primary key default gen_random_uuid(),
   notebook_id uuid not null references notebooks(id) on delete cascade,
   source_id text,
   content text not null,
-  embedding vector(1536),
+  embedding vector(384),
   metadata jsonb,
   created_at timestamptz default now()
 );
 create index if not exists idx_chunks_notebook_id on chunks(notebook_id);
--- Vector index (run after you have data; ivfflat requires rows):
--- create index idx_chunks_embedding on chunks using ivfflat (embedding vector_cosine_ops) with (lists = 100);
+
+-- Vector index for fast similarity search (run after chunks have data; ivfflat requires rows)
+create index if not exists idx_chunks_embedding on chunks using ivfflat (embedding vector_cosine_ops) with (lists = 100);
+
+-- RPC for RAG retrieval: top-k chunks by cosine similarity, filtered by notebook_id
+create or replace function match_chunks(
+  query_embedding vector(384),
+  match_count int,
+  p_notebook_id uuid
+)
+returns table (id uuid, content text, metadata jsonb, similarity float)
+language plpgsql as $$
+begin
+  return query
+  select c.id, c.content, c.metadata,
+         1 - (c.embedding <=> query_embedding) as similarity
+  from chunks c
+  where c.notebook_id = p_notebook_id
+    and c.embedding is not null
+  order by c.embedding <=> query_embedding
+  limit match_count;
+end;
+$$;
 
 -- sources table (ingestion pipeline)
 create table if not exists sources (

requirements.txt

@@ -5,5 +5,6 @@ python-dotenv>=1.0.0
 realtime==2.3.0
 chardet>=5.0.0
 sentence-transformers>=2.0.0
+einops>=0.7.0
 pypdf>=4.2.0
 beautifulsoup4>=4.12.3

run.bat

@@ -0,0 +1,33 @@
+@echo off
+REM Gradio has issues with Python 3.13 - use 3.10, 3.11, or 3.12
+echo Checking for Python 3.10/3.11/3.12...
+py -3.10 --version 2>nul && goto run310
+py -3.11 --version 2>nul && goto run311
+py -3.12 --version 2>nul && goto run312
+echo.
+echo Python 3.10, 3.11, or 3.12 not found.
+echo Gradio does NOT work with Python 3.13.
+echo Install Python 3.10 from https://www.python.org/downloads/
+pause
+exit /b 1
+
+:run310
+echo Using Python 3.10
+py -3.10 -m pip install -r requirements.txt -q
+py -3.10 app.py
+goto end
+
+:run311
+echo Using Python 3.11
+py -3.11 -m pip install -r requirements.txt -q
+py -3.11 app.py
+goto end
+
+:run312
+echo Using Python 3.12
+py -3.12 -m pip install -r requirements.txt -q
+py -3.12 app.py
+goto end
+
+:end
+pause