Merge pull request #2 from tAnboyy/feature/notebookcrud-supabase-frontend

.gitignore

@@ -37,3 +37,6 @@ logs/
 # Gradio temp files
 gradio_cached_examples/
 flagged/
+
+# User data storage
+data/

HANDOFF_NOTEBOOKS.md

@@ -0,0 +1,192 @@
+# NotebookLM Clone - Handoff Document
+
+## Stack
+
+- **Auth:** Hugging Face OAuth (`gr.LoginButton`, `user_id` = HF username)
+- **Metadata:** Supabase (notebooks, messages, artifacts)
+- **Files:** Supabase Storage bucket `notebooklm`
+- **Vectors:** Supabase pgvector (chunks table)
+
+## Setup
+
+### 1. Supabase
+
+- Run `db/schema.sql` in SQL Editor
+- Create Storage bucket: **Storage** → **New bucket** → name `notebooklm`, set public/private as needed
+- Add RLS policies for the bucket if using private access
+
+### 2. HF Space
+
+- Add `hf_oauth: true` in README (already done)
+- Add `SUPABASE_URL`, `SUPABASE_KEY` (service role) as Space secrets
+- Optional: `SUPABASE_BUCKET` (default: notebooklm)
+
+### 3. Local
+
+- `HF_TOKEN` env var or `huggingface-cli login` (required for OAuth mock)
+- `.env` with `SUPABASE_URL`, `SUPABASE_KEY`
+- `pip install gradio[oauth]` (or `itsdangerous`) for LoginButton
+
+## Storage (Supabase Storage)
+
+```python
+from backend.storage import get_sources_path, save_file, load_file
+
+# Ingestion: save uploaded PDF
+prefix = get_sources_path(user_id, notebook_id)  # "user_id/notebook_id/sources"
+path = f"{prefix}/document.pdf"
+save_file(path, file_bytes)
+
+# Load
+data = load_file(path)
+```
+
+Paths: `{user_id}/{notebook_id}/sources|embeddings|chats|artifacts}/{filename}`
+
+## Notebook API
+
+- `create_notebook(user_id, name)` 
+- `list_notebooks(user_id)`
+- `rename_notebook(user_id, notebook_id, new_name)`
+- `delete_notebook(user_id, notebook_id)`
+
+## Chat (Supabase messages table)
+
+- `save_message(notebook_id, role, content)`
+- `load_chat(notebook_id)`
+
+## Embeddings (pgvector)
+
+Table `chunks`: id, notebook_id, source_id, content, embedding vector(1536), metadata, created_at.
+
+Ingestion team: embed chunks, insert into `chunks`, filter by `notebook_id` for retrieval.
+
+---
+
+## Handover: Ingestion & RAG Builders
+
+### Where to Write Your Code
+
+| Responsibility | File / Location | Purpose |
+|----------------|-----------------|---------|
+| **Ingestion**  | `backend/ingestion_service.py` (create this) | Parse uploaded files, chunk text, compute embeddings, insert into `chunks` |
+| **RAG**        | `backend/rag_service.py` (create this)      | Embed query → similarity search → build context → call LLM → return answer |
+| **Storage**    | `backend/storage.py` (existing)             | Save/load files in Supabase Storage; do not modify |
+| **Chat**       | `backend/chat_service.py` (existing)        | Save/load messages; RAG calls `save_message` and `load_chat` |
+| **UI**         | `app.py`                                   | Add upload component + chat interface; wire to ingestion and RAG |
+
+---
+
+### Ingestion Builder
+
+**Write your code in:** `backend/ingestion_service.py`
+
+**Flow:**
+1. Receive: `user_id`, `notebook_id`, uploaded file bytes, and filename.
+2. Save raw file via storage:
+   ```python
+   from backend.storage import get_sources_path, save_file
+   prefix = get_sources_path(user_id, notebook_id)  # → "user_id/notebook_id/sources"
+   path = f"{prefix}/{filename}"
+   save_file(path, file_bytes)
+   ```
+3. Parse file (PDF, DOCX, TXT, etc.) and extract text.
+4. Chunk text (e.g., 512–1024 tokens with overlap).
+5. Compute embeddings (e.g., OpenAI `text-embedding-3-small` → 1536 dims, or compatible).
+6. Insert rows into `chunks`:
+   ```python
+   supabase.table("chunks").insert({
+       "notebook_id": notebook_id,
+       "source_id": path,  # or your source identifier
+       "content": chunk_text,
+       "embedding": embedding_list,  # list of 1536 floats
+       "metadata": {"page": 1, "chunk_idx": 0}  # optional
+   }).execute()
+   ```
+
+**Integrate in app:**
+- Add `gr.File` or `gr.Upload` in `app.py` for the selected notebook.
+- On upload, call `ingest_file(user_id, notebook_id, file_bytes, filename)` from your new service.
+
+**Existing helpers:** `backend/storage` (save_file, load_file, list_files, get_sources_path).
+
+---
+
+### RAG Builder
+
+**Write your code in:** `backend/rag_service.py`
+
+**Flow:**
+1. Receive: `notebook_id`, user query.
+2. Embed the query (same model/dims as ingestion, e.g. 1536).
+3. Similarity search in `chunks`:
+   ```python
+   # Supabase pgvector example (cosine similarity)
+   result = supabase.rpc(
+       "match_chunks",
+       {"query_embedding": embedding, "match_count": 5, "p_notebook_id": notebook_id}
+   ).execute()
+   ```
+   - You must add a Supabase function `match_chunks` that filters by `notebook_id` and runs vector similarity (or use raw SQL).
+   - Alternative: use `supabase.table("chunks").select("*").eq("notebook_id", notebook_id)` and do similarity in Python (less efficient).
+4. Build context from top-k chunks.
+5. Call LLM (Hugging Face Inference API, OpenAI, etc.) with context + history.
+6. Persist messages via `chat_service`:
+   ```python
+   from backend.chat_service import save_message, load_chat
+   save_message(notebook_id, "user", query)
+   save_message(notebook_id, "assistant", answer)
+   ```
+
+**Integrate in app:**
+- Add a chat block in `app.py` (Chatbot component) tied to `selected_notebook_id`.
+- On submit: call `rag_chat(notebook_id, query, chat_history)` → returns assistant reply; update history using `load_chat(notebook_id)` or append locally.
+
+**Existing helpers:** `backend/chat_service` (save_message, load_chat), `backend/db` (supabase).
+
+---
+
+### Schema Reference (for both)
+
+```sql
+-- chunks table (db/schema.sql)
+chunks (
+  id uuid,
+  notebook_id uuid,
+  source_id text,
+  content text,
+  embedding vector(1536),
+  metadata jsonb,
+  created_at timestamptz
+)
+```
+
+**Required:** `embedding` must be 1536 dimensions (or update schema if using a different model).
+
+---
+
+### Suggested RPC for RAG (optional)
+
+Add this in Supabase SQL Editor if you prefer server-side similarity:
+
+```sql
+create or replace function match_chunks(
+  query_embedding vector(1536),
+  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
+  order by c.embedding <=> query_embedding
+  limit match_count;
+end;
+$$;
+```
+
+Ingestion writes to `chunks`; RAG reads via `match_chunks` or equivalent.

README.md

@@ -8,6 +8,12 @@ sdk_version: "4.44.0"
 python_version: "3.10"
 app_file: app.py
 pinned: false
+
+hf_oauth: true
+hf_oauth_expiration_minutes: 480
+hf_oauth_scopes:
+  - email
+  - read-repos
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,7 +1,232 @@
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+# Load .env from project root (parent of NotebookLM-Clone) so HF_TOKEN etc. are available
+load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+load_dotenv(Path(__file__).resolve().parent / ".env")
+
 import gradio as gr
 
-def greet(name):
-    return "Hello " + name + "!!. Testing Hugging Face deployment!"
+from backend.notebook_service import create_notebook, list_notebooks, rename_notebook, delete_notebook
+
+# Theme: adapts to light/dark mode
+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; }
+@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; }
+}
+.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; }
+"""
+
+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
+
+
+def _get_notebooks(user_id: str | None):
+    if not user_id:
+        return []
+    return list_notebooks(user_id)
+
+
+def _safe_create(new_name, state, selected_id, profile: gr.OAuthProfile | None):
+    """Create notebook with name from text box."""
+    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))
+        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"]
+            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))
+    except Exception as e:
+        return gr.skip(), gr.skip(), gr.skip(), f"Error: {e}", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+
+
+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))
+        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))
+        user_id = _user_id(profile)
+        if not user_id:
+            return gr.skip(), gr.skip(), gr.skip(), "Please sign in", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+        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))
+    except Exception as e:
+        return gr.skip(), gr.skip(), gr.skip(), f"Error: {e}", *([gr.skip()] * (MAX_NOTEBOOKS * 2))
+
+
+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))
+        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))
+        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_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))
+    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]
+
+
+def _initial_load(profile: gr.OAuthProfile | None):
+    """Load notebooks on app load. Uses HF OAuth profile for user_id."""
+    user_id = _user_id(profile)
+    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
+
+
+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
+
+
+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)
+
+    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="",
+                show_label=False,
+                scale=3,
+                min_width=200,
+            )
+            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])
+
+    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)
+
+    # Create button
+    create_btn.click(
+        _safe_create,
+        inputs=[create_txt, nb_state, selected_notebook_id],
+        outputs=[create_txt, nb_state, selected_notebook_id, status] + row_outputs,
+    )
+
+    # 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,
+        )
+        delete_btn.click(
+            _safe_delete,
+            inputs=[gr.State(i), nb_state, selected_notebook_id],
+            outputs=[nb_state, selected_notebook_id, status] + row_outputs,
+        )
+        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],
+        ).then(_on_select, None, [status])
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
 demo.launch()

backend/__init__.py

@@ -0,0 +1 @@
+"""Backend services: storage, notebooks, chat."""

backend/artifacts_service.py

@@ -0,0 +1,31 @@
+"""Artifacts - store references to generated reports, quizzes, podcasts, etc."""
+
+from backend.db import supabase
+
+
+def create_artifact(notebook_id: str, type: str, storage_path: str) -> dict | None:
+    """Create artifact record. Returns {id, notebook_id, type, storage_path, created_at} or None."""
+    try:
+        result = supabase.table("artifacts").insert({
+            "notebook_id": notebook_id,
+            "type": type,
+            "storage_path": storage_path,
+        }).execute()
+        return result.data[0] if result.data else None
+    except Exception:
+        return None
+
+
+def list_artifacts(notebook_id: str) -> list[dict]:
+    """List artifacts for notebook. Returns [{id, type, storage_path, created_at}, ...]."""
+    try:
+        result = (
+            supabase.table("artifacts")
+            .select("id, type, storage_path, created_at")
+            .eq("notebook_id", notebook_id)
+            .order("created_at", desc=True)
+            .execute()
+        )
+        return result.data or []
+    except Exception:
+        return []

backend/chat_service.py

@@ -0,0 +1,25 @@
+"""Chat persistence - save/load messages via Supabase messages table."""
+
+from backend.db import supabase
+
+
+def save_message(notebook_id: str, role: str, content: str) -> None:
+    """Append a message to the messages table."""
+    supabase.table("messages").insert({
+        "notebook_id": notebook_id,
+        "role": role,
+        "content": content,
+    }).execute()
+
+
+def load_chat(notebook_id: str) -> list[dict]:
+    """Load chat history. Returns [{role, content, created_at}, ...]."""
+    result = (
+        supabase.table("messages")
+        .select("role, content, created_at")
+        .eq("notebook_id", notebook_id)
+        .order("created_at")
+        .execute()
+    )
+    rows = result.data or []
+    return [{"role": r["role"], "content": r["content"], "timestamp": r["created_at"]} for r in rows]

backend/db.py

@@ -0,0 +1,17 @@
+"""Shared Supabase client."""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+from supabase import create_client, Client
+
+load_dotenv(Path(__file__).resolve().parent.parent.parent / ".env")
+load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+
+url = os.getenv("SUPABASE_URL")
+key = os.getenv("SUPABASE_KEY")
+if not url or not key:
+    raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set")
+
+supabase: Client = create_client(url, key)

backend/notebook_service.py

@@ -0,0 +1,75 @@
+"""Notebook CRUD service - spec-aligned API, Supabase + storage."""
+
+import logging
+from datetime import datetime, timezone
+
+from backend.db import supabase
+from backend.storage import ensure_notebook_dirs
+
+log = logging.getLogger(__name__)
+
+
+def _to_spec(row: dict) -> dict:
+    """Map DB row to spec format."""
+    return {
+        "notebook_id": str(row["id"]),
+        "name": row["name"],
+        "created_at": row.get("created_at"),
+    }
+
+
+def create_notebook(user_id: str, name: str = "Untitled Notebook") -> dict | None:
+    """Create notebook. Returns {notebook_id, name, created_at} or None on error."""
+    try:
+        data = {"user_id": user_id, "name": name}
+        result = supabase.table("notebooks").insert(data).execute()
+        rows = result.data
+        if not rows:
+            return None
+        row = rows[0]
+        nb_id = str(row["id"])
+        ensure_notebook_dirs(user_id, nb_id)
+        return _to_spec(row)
+    except Exception as e:
+        log.exception("create_notebook failed")
+        return None
+
+
+def list_notebooks(user_id: str) -> list[dict]:
+    """List notebooks for user. Returns [{notebook_id, name, created_at}, ...]."""
+    try:
+        result = (
+            supabase.table("notebooks")
+            .select("*")
+            .eq("user_id", user_id)
+            .order("updated_at", desc=True)
+            .execute()
+        )
+        return [_to_spec(r) for r in (result.data or [])]
+    except Exception as e:
+        log.exception("list_notebooks failed")
+        return []
+
+
+def rename_notebook(user_id: str, notebook_id: str, new_name: str) -> bool:
+    """Rename notebook. Returns success."""
+    try:
+        result = (
+            supabase.table("notebooks")
+            .update({"name": new_name, "updated_at": datetime.now(timezone.utc).isoformat()})
+            .eq("id", notebook_id)
+            .eq("user_id", user_id)
+            .execute()
+        )
+        return len(result.data or []) > 0
+    except Exception:
+        return False
+
+
+def delete_notebook(user_id: str, notebook_id: str) -> bool:
+    """Delete notebook. Returns success."""
+    try:
+        supabase.table("notebooks").delete().eq("id", notebook_id).eq("user_id", user_id).execute()
+        return True
+    except Exception:
+        return False

backend/storage.py

@@ -0,0 +1,88 @@
+"""
+Storage layer - Supabase Storage for files.
+Path structure: {user_id}/{notebook_id}/sources/, embeddings/, chats/, artifacts/
+"""
+
+import os
+from pathlib import Path
+
+from backend.db import supabase
+
+BUCKET = os.getenv("SUPABASE_BUCKET", "notebooklm")
+
+
+def _validate_segment(s: str) -> bool:
+    """Reject path traversal and invalid chars."""
+    if not s or ".." in s or "/" in s or "\\" in s:
+        return False
+    return True
+
+
+def _base_path(user_id: str, notebook_id: str) -> str:
+    """Return base path for notebook. Raises on invalid input."""
+    if not _validate_segment(user_id) or not _validate_segment(notebook_id):
+        raise ValueError("Invalid user_id or notebook_id (path safety)")
+    return f"{user_id}/{notebook_id}"
+
+
+def get_sources_path(user_id: str, notebook_id: str) -> str:
+    """Path prefix for notebook sources. Ingestion saves uploads here."""
+    return f"{_base_path(user_id, notebook_id)}/sources"
+
+
+def get_embeddings_path(user_id: str, notebook_id: str) -> str:
+    """Path prefix for embeddings."""
+    return f"{_base_path(user_id, notebook_id)}/embeddings"
+
+
+def get_chats_path(user_id: str, notebook_id: str) -> str:
+    """Path prefix for chat files."""
+    return f"{_base_path(user_id, notebook_id)}/chats"
+
+
+def get_artifacts_path(user_id: str, notebook_id: str) -> str:
+    """Path prefix for artifacts."""
+    return f"{_base_path(user_id, notebook_id)}/artifacts"
+
+
+def ensure_notebook_dirs(user_id: str, notebook_id: str) -> None:
+    """No-op for Supabase Storage - paths are created on first upload."""
+    _base_path(user_id, notebook_id)
+
+
+def save_file(storage_path: str, content: bytes | str) -> None:
+    """Save content to Supabase Storage. Path must be within bucket (no leading /)."""
+    if ".." in storage_path or storage_path.startswith("/"):
+        raise ValueError("Invalid storage path")
+    data = content.encode("utf-8") if isinstance(content, str) else content
+    supabase.storage.from_(BUCKET).upload(
+        path=storage_path,
+        file=data,
+        file_options={"upsert": "true"},
+    )
+
+
+def load_file(storage_path: str) -> bytes:
+    """Load file from Supabase Storage. Returns bytes."""
+    if ".." in storage_path or storage_path.startswith("/"):
+        raise ValueError("Invalid storage path")
+    return supabase.storage.from_(BUCKET).download(storage_path)
+
+
+def list_files(prefix: str) -> list[str]:
+    """List file paths under prefix."""
+    try:
+        result = supabase.storage.from_(BUCKET).list(prefix.rstrip("/"))
+        paths = []
+        for item in result:
+            name = item.get("name") if isinstance(item, dict) else getattr(item, "name", None)
+            if not name or name == ".emptyFolderPlaceholder":
+                continue
+            path = f"{prefix.rstrip('/')}/{name}"
+            if isinstance(item, dict) and item.get("id") is None:  # folder
+                paths.extend(list_files(path + "/"))
+            else:
+                paths.append(path)
+        return paths
+    except Exception:
+        return []

db/schema.sql

@@ -0,0 +1,48 @@
+-- Run this in Supabase SQL Editor
+
+-- notebooks (existing)
+create table if not exists notebooks (
+  id uuid primary key default gen_random_uuid(),
+  user_id text not null,
+  name varchar(255) not null default 'Untitled Notebook',
+  created_at timestamptz default now(),
+  updated_at timestamptz default now()
+);
+create index if not exists idx_notebooks_user_id on notebooks(user_id);
+
+-- messages
+create table if not exists messages (
+  id uuid primary key default gen_random_uuid(),
+  notebook_id uuid not null references notebooks(id) on delete cascade,
+  role text not null,
+  content text not null,
+  created_at timestamptz default now()
+);
+create index if not exists idx_messages_notebook_id on messages(notebook_id);
+
+-- artifacts
+create table if not exists artifacts (
+  id uuid primary key default gen_random_uuid(),
+  notebook_id uuid not null references notebooks(id) on delete cascade,
+  type text not null,
+  storage_path text not null,
+  created_at timestamptz default now()
+);
+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)
+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),
+  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);

requirements.txt

@@ -1,2 +1,5 @@
-gradio==4.44.0
+gradio[oauth]==4.44.0
 huggingface_hub==0.24.7
+supabase>=2.0.0
+python-dotenv>=1.0.0
+realtime==2.3.0