upload files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+public/heroImage.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+.kiro
+.venv
+__pycache__
+captions.json

README.md

@@ -1,15 +1,56 @@
----
-title: ShutterSearch
-emoji: ⚡
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: A semantic search platform built for photographers
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Photographer's Archive
+emoji: 📷
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: "5"
+app_file: app.py
+pinned: false
+license: apache-2.0
+tags:
+  - backyard-ai
+  - build-small
+  - vision-language-model
+  - image-search
+  - local-first
+short_description: Local-first photo search powered by MiniCPM-V-4.6
+---
+
+# Photographer's Archive
+
+A local-first, privacy-preserving photo search app for photographers. Built for the Hugging Face [Build Small](https://huggingface.co/build-small) hackathon — **Backyard AI** track.
+
+## What it does
+
+1. **Ingest** — Point the app at a local folder of photos. A small Vision-Language Model (MiniCPM-V-4.6, ≤7B params) runs entirely on your machine and generates rich captions describing objects, lighting, mood, and composition.
+2. **Search** — Type a plain-English query (e.g. "golden hour portrait with soft bokeh") and instantly retrieve the most relevant photos ranked by semantic similarity.
+
+No images are uploaded to any external service. Everything stays on your hardware.
+
+## Demo
+
+> 📹 Demo video: _link TBD_  
+> 🐦 Social post: _link TBD_
+
+## Running locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+The first run will download MiniCPM-V-4.6 (~8 GB). Subsequent runs use cached weights and work fully offline.
+
+## Tech stack
+
+| Component | Library |
+|-----------|---------|
+| VLM | `openbmb/MiniCPM-V-4.6` via 🤗 Transformers |
+| Semantic search | `sentence-transformers/all-MiniLM-L6-v2` |
+| UI | Gradio 5 |
+| Caption store | Local `captions.json` |
+
+## Privacy
+
+All model inference happens locally. No image pixels, captions, or metadata leave your machine.

app.py

@@ -0,0 +1,380 @@
+# import gradio as gr
+
+# # Ensure the new dropdown helpers are imported
+# from logic import (
+#     run_ingest, run_search, load_caption_browser, load_collections_view,
+#     update_collections_dropdown, update_search_dropdown
+# )
+# from caption_store import entry_count, get_all_collections
+
+# # Import UI Views
+# from ui.sidebar import render_sidebar
+# from ui.home import render_home
+# from ui.ingest import render_ingest
+# from ui.search import render_search
+# from ui.collections import render_collections
+# from ui.captions import render_captions
+# from ui.about import render_about
+
+# # Define explicit Dark Mode theme variables
+# # dark_theme = gr.themes.Soft(
+# #     primary_hue="green", 
+# #     secondary_hue="emerald"
+# # ).set(
+# #     body_background_fill="#0b0f19",
+# #     body_background_fill_dark="#0b0f19",
+# #     block_background_fill="#1e293b",
+# #     block_background_fill_dark="#1e293b",
+# #     block_border_color="#334155",
+# #     block_border_color_dark="#334155",
+# #     input_background_fill="#0f172a",
+# #     input_background_fill_dark="#0f172a",
+# #     text_color="#f1f5f9",
+# #     text_color_dark="#f1f5f9",
+# # )
+
+# # Load Custom Stylesheet
+# with open("style.css", "r") as f:
+#     custom_css = f.read()
+
+# with gr.Blocks(css=custom_css) as demo:
+#     # 1. Render Navigation Sidebar
+#     nav_btns, stats_label = render_sidebar()
+
+#     # 2. Render Main Content Container Pages
+#     with gr.Column(elem_classes="main-content"):
+#         home_page, start_btn = render_home()
+#         ingest_page, upload, coll_dropdown, use_new_coll, new_coll_name, ingest_btn, ingest_status = render_ingest()
+#         search_page, search_query, search_col_filter, search_btn, search_status_msg, search_gallery = render_search()
+#         colls_page, view_coll_selector, refresh_coll_btn, coll_status, coll_gallery = render_collections()
+#         caps_page, refresh_cap_btn, cap_status, caption_table = render_captions()
+#         about_page = render_about()
+
+#     # Routing definitions
+#     pages = [home_page, ingest_page, search_page, colls_page, caps_page, about_page]
+#     page_names = ["home", "ingest", "search", "collections", "captions", "about"]
+
+#     def switch_page(page_name):
+#         return [gr.update(visible=(name == page_name)) for name in page_names]
+
+#     # --- Page Routing Event Handlers ---
+#     nav_btns["home"].click(fn=lambda: switch_page("home"), outputs=pages)
+#     nav_btns["ingest"].click(fn=lambda: switch_page("ingest"), outputs=pages)
+    
+#     # Use logic helpers to keep dropdown selections safe when changing tabs
+#     nav_btns["search"].click(
+#         fn=lambda: switch_page("search") + [update_search_dropdown()], 
+#         outputs=pages + [search_col_filter]
+#     )
+#     nav_btns["collections"].click(
+#         fn=lambda: switch_page("collections") + [update_collections_dropdown()], 
+#         outputs=pages + [view_coll_selector]
+#     )
+    
+#     nav_btns["captions"].click(fn=lambda: switch_page("captions"), outputs=pages)
+#     nav_btns["about"].click(fn=lambda: switch_page("about"), outputs=pages)
+    
+#     start_btn.click(fn=lambda: switch_page("ingest"), outputs=pages)
+
+#     # --- Component Value Interaction Bindings ---
+    
+#     # Toggle dropdown/text field depending on toggle state
+#     def toggle_collection_inputs(is_new):
+#         return (
+#             gr.update(visible=not is_new),  # Hide selector if creating new
+#             gr.update(visible=is_new)       # Show text box if creating new
+#         )
+    
+#     use_new_coll.change(
+#         fn=toggle_collection_inputs, 
+#         inputs=use_new_coll, 
+#         outputs=[coll_dropdown, new_coll_name]
+#     )
+    
+#     ingest_btn.click(
+#         fn=run_ingest, 
+#         inputs=[upload, coll_dropdown, use_new_coll, new_coll_name], 
+#         outputs=[ingest_status, caption_table, coll_dropdown]
+#     ).then(
+#         fn=lambda: f"Total Photos: {entry_count()}", 
+#         outputs=stats_label
+#     )
+
+#     # Search Logic Action triggers
+#     search_btn.click(fn=run_search, inputs=[search_query, search_col_filter], outputs=[search_gallery, search_status_msg])
+#     search_query.submit(fn=run_search, inputs=[search_query, search_col_filter], outputs=[search_gallery, search_status_msg])
+
+#     # Gallery view loaders
+#     view_coll_selector.change(fn=load_collections_view, inputs=view_coll_selector, outputs=[coll_gallery, coll_status])
+#     refresh_coll_btn.click(fn=load_collections_view, inputs=view_coll_selector, outputs=[coll_gallery, coll_status])
+
+#     # Captions refresh actions
+#     refresh_cap_btn.click(fn=load_caption_browser, outputs=[caption_table, cap_status])
+    
+#     # Initial startup data population
+#     demo.load(fn=load_caption_browser, outputs=[caption_table, cap_status])
+#     demo.load(
+#         fn=lambda: load_collections_view(get_all_collections()[0] if get_all_collections() else "General"), 
+#         outputs=[coll_gallery, coll_status]
+#     )
+
+# if __name__ == "__main__":
+#     demo.launch()
+
+import os
+import gradio as gr
+
+# Import robust business logic operations
+from logic import (
+    run_ingest, run_search, load_caption_browser, load_collections_view,
+    update_collections_dropdown, update_search_dropdown, zip_selected_files
+)
+from caption_store import entry_count, get_all_collections
+
+# Import modular UI Page builders
+from ui.sidebar import render_sidebar
+from ui.home import render_home
+from ui.ingest import render_ingest
+from ui.search import render_search
+from ui.collections import render_collections
+from ui.captions import render_captions
+from ui.about import render_about
+
+# Load layout parameters from global stylesheet
+with open("style.css", "r") as f:
+    custom_css = f.read()
+
+with gr.Blocks(css=custom_css) as demo:
+    # 1. Render Navigation Sidebar
+    nav_btns, stats_label = render_sidebar()
+
+    # 2. Render Main Content Container Pages
+    with gr.Column(elem_classes="main-content"):
+        home_page, start_btn = render_home()
+        ingest_page, upload, coll_dropdown, use_new_coll, new_coll_name, ingest_btn, ingest_status = render_ingest()
+        
+        # Search layout with selection returns
+        (
+            search_page, search_query, search_col_filter, search_btn, search_status_msg, search_gallery,
+            selected_search_paths, loaded_search_paths, search_selection_status, search_download_btn,
+            search_download_file, search_clear_selection_btn, search_select_all_btn
+        ) = render_search()
+        
+        # Collections layout with selection returns
+        (
+            colls_page, view_coll_selector, refresh_coll_btn, coll_status, coll_gallery, 
+            selected_paths, loaded_original_paths, selection_status, download_btn, 
+            download_file, clear_selection_btn, select_all_btn
+        ) = render_collections()
+        
+        caps_page, refresh_cap_btn, cap_status, caption_table = render_captions()
+        about_page = render_about()
+
+    # Define page indexes for visibility toggles
+    pages = [home_page, ingest_page, search_page, colls_page, caps_page, about_page]
+    page_names = ["home", "ingest", "search", "collections", "captions", "about"]
+
+    def switch_page(page_name):
+        """Generates dynamic updates to manage current visible pages."""
+        return [gr.update(visible=(name == page_name)) for name in page_names]
+
+    # --- Sidebar Navigation Interactions ---
+    nav_btns["home"].click(fn=lambda: switch_page("home"), outputs=pages)
+    nav_btns["ingest"].click(fn=lambda: switch_page("ingest"), outputs=pages)
+    
+    # Safe helpers are invoked here to avoid component value schema mismatch issues
+    nav_btns["search"].click(
+        fn=lambda: switch_page("search") + [update_search_dropdown()], 
+        outputs=pages + [search_col_filter]
+    )
+    nav_btns["collections"].click(
+        fn=lambda: switch_page("collections") + [update_collections_dropdown()], 
+        outputs=pages + [view_coll_selector]
+    )
+    
+    nav_btns["captions"].click(fn=lambda: switch_page("captions"), outputs=pages)
+    nav_btns["about"].click(fn=lambda: switch_page("about"), outputs=pages)
+    
+    start_btn.click(fn=lambda: switch_page("ingest"), outputs=pages)
+
+    # --- Ingestion View Handlers ---
+    def toggle_collection_inputs(is_new):
+        """Toggles rendering states of manual and standard collections selectors."""
+        return (
+            gr.update(visible=not is_new),  # Hide selector if creating new
+            gr.update(visible=is_new)       # Show text box if creating new
+        )
+    
+    use_new_coll.change(
+        fn=toggle_collection_inputs, 
+        inputs=use_new_coll, 
+        outputs=[coll_dropdown, new_coll_name]
+    )
+    
+    ingest_btn.click(
+        fn=run_ingest, 
+        inputs=[upload, coll_dropdown, use_new_coll, new_coll_name], 
+        outputs=[ingest_status, caption_table, coll_dropdown]
+    ).then(
+        fn=lambda: f"Total Photos: {entry_count()}", 
+        outputs=stats_label
+    )
+
+    # --- Shared Selection Utility Functions ---
+    def format_selection_status(count, filenames):
+        """Generates double-linebreak formatted selection statuses to divide output lines."""
+        if count == 0:
+            return "**0** image(s) selected for download packaging.\n\n*No files currently selected.*"
+        
+        name_string = ", ".join(filenames)
+        if len(name_string) > 150:
+            name_string = name_string[:150] + "..."
+        # Double linebreak forces a paragraph divide onto a separate line
+        return f"**{count}** image(s) selected for download packaging.\n\n📋 **Selected Files:** `{name_string}`"
+
+    def handle_gallery_selection(evt: gr.SelectData, current_selections, raw_paths, gallery_data):
+        """Toggles visual labels dynamically and outputs double-linebreak reports."""
+        clicked_file = raw_paths[evt.index]
+        if clicked_file in current_selections:
+            current_selections.remove(clicked_file)
+        else:
+            current_selections.append(clicked_file)
+            
+        updated_gallery = []
+        for idx, path in enumerate(raw_paths):
+            thumb_path = gallery_data[idx][0]
+            basename = os.path.basename(path)
+            label = f"✅ {basename}" if path in current_selections else basename
+            updated_gallery.append((thumb_path, label))
+
+        filenames = [os.path.basename(f) for f in current_selections]
+        summary = format_selection_status(len(current_selections), filenames)
+        return current_selections, summary, updated_gallery
+
+    def handle_select_all(raw_paths, gallery_data):
+        """Packages all source paths inside current array list and displays checkmarks."""
+        if not raw_paths:
+            return [], format_selection_status(0, []), []
+        
+        current_selections = list(raw_paths)
+        updated_gallery = []
+        for idx, path in enumerate(raw_paths):
+            thumb_path = gallery_data[idx][0]
+            basename = os.path.basename(path)
+            updated_gallery.append((thumb_path, f"✅ {basename}"))
+            
+        filenames = [os.path.basename(f) for f in current_selections]
+        summary = format_selection_status(len(current_selections), filenames)
+        return current_selections, summary, updated_gallery
+
+    def clear_selection(raw_paths, gallery_data):
+        """Flushes storage state lists and clears visual checkmarks from labels."""
+        updated_gallery = []
+        for idx, path in enumerate(raw_paths):
+            thumb_path = gallery_data[idx][0]
+            basename = os.path.basename(path)
+            updated_gallery.append((thumb_path, basename))
+            
+        return [], format_selection_status(0, []), updated_gallery, gr.update(visible=False)
+
+    def handle_selected_download(selected_list):
+        """Compiles specified absolute paths into a downloadable archive container."""
+        if not selected_list:
+            return gr.update(visible=False), "⚠️ Download failure: No selections marked."
+        file_path, status_msg = zip_selected_files(selected_list)
+        if file_path:
+            return gr.update(value=file_path, visible=True), status_msg
+        return gr.update(visible=False), status_msg
+
+
+    # --- Search View Bindings ---
+    def trigger_search_load(query, col_filter):
+        images, original_paths, status = run_search(query, col_filter)
+        return images, original_paths, [], format_selection_status(0, []), status, gr.update(visible=False)
+
+    search_btn.click(
+        fn=trigger_search_load,
+        inputs=[search_query, search_col_filter],
+        outputs=[search_gallery, loaded_search_paths, selected_search_paths, search_selection_status, search_status_msg, search_download_file]
+    )
+    search_query.submit(
+        fn=trigger_search_load,
+        inputs=[search_query, search_col_filter],
+        outputs=[search_gallery, loaded_search_paths, selected_search_paths, search_selection_status, search_status_msg, search_download_file]
+    )
+
+    # Search Interactive Select Hooks
+    search_gallery.select(
+        fn=handle_gallery_selection,
+        inputs=[selected_search_paths, loaded_search_paths, search_gallery],
+        outputs=[selected_search_paths, search_selection_status, search_gallery]
+    )
+    search_select_all_btn.click(
+        fn=handle_select_all,
+        inputs=[loaded_search_paths, search_gallery],
+        outputs=[selected_search_paths, search_selection_status, search_gallery]
+    )
+    search_clear_selection_btn.click(
+        fn=clear_selection,
+        inputs=[loaded_search_paths, search_gallery],
+        outputs=[selected_search_paths, search_selection_status, search_gallery, search_download_file]
+    )
+    search_download_btn.click(
+        fn=handle_selected_download,
+        inputs=selected_search_paths,
+        outputs=[search_download_file, search_selection_status]
+    )
+
+
+    # --- Collections View Bindings ---
+    def trigger_collection_load(selected_collection):
+        images, original_paths, status = load_collections_view(selected_collection)
+        return images, original_paths, [], format_selection_status(0, []), gr.update(visible=False)
+
+    view_coll_selector.change(
+        fn=trigger_collection_load, 
+        inputs=view_coll_selector, 
+        outputs=[coll_gallery, loaded_original_paths, selected_paths, selection_status, download_file]
+    )
+    refresh_coll_btn.click(
+        fn=trigger_collection_load, 
+        inputs=view_coll_selector, 
+        outputs=[coll_gallery, loaded_original_paths, selected_paths, selection_status, download_file]
+    )
+
+    # Collections Interactive Select Hooks
+    coll_gallery.select(
+        fn=handle_gallery_selection,
+        inputs=[selected_paths, loaded_original_paths, coll_gallery],
+        outputs=[selected_paths, selection_status, coll_gallery]
+    )
+    select_all_btn.click(
+        fn=handle_select_all,
+        inputs=[loaded_original_paths, coll_gallery],
+        outputs=[selected_paths, selection_status, coll_gallery]
+    )
+    clear_selection_btn.click(
+        fn=clear_selection,
+        inputs=[loaded_original_paths, coll_gallery],
+        outputs=[selected_paths, selection_status, coll_gallery, download_file]
+    )
+    download_btn.click(
+        fn=handle_selected_download,
+        inputs=selected_paths,
+        outputs=[download_file, selection_status]
+    )
+
+
+    # --- Caption Browser Refresh Bindings ---
+    refresh_cap_btn.click(fn=load_caption_browser, outputs=[caption_table, cap_status])
+
+    # Initial startup payload loaders
+    demo.load(fn=load_caption_browser, outputs=[caption_table, cap_status])
+    demo.load(
+        fn=trigger_collection_load, 
+        inputs=view_coll_selector, 
+        outputs=[coll_gallery, loaded_original_paths, selected_paths, selection_status, download_file]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

app_old.py

@@ -0,0 +1,296 @@
+"""Photographer's Archive — Gradio app entry point."""
+
+import json
+import logging
+import os
+import shutil
+import tempfile
+
+import gradio as gr
+
+from caption_store import all_entries, entry_count, get_all_collections, get_entries_by_collection
+from ingest import ingest_folder
+from search import MIN_RELEVANCE, search
+
+logging.basicConfig(level=logging.INFO)
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".tiff"}
+
+STAGING_DIR = os.path.join(tempfile.gettempdir(), "photographers_archive_uploads")
+os.makedirs(STAGING_DIR, exist_ok=True)
+
+
+def run_ingest(uploaded_files, collection_name, is_new_collection, new_collection_name):
+    if not uploaded_files:
+        yield "Please upload at least one image or a folder of images.", gr.update(), gr.update()
+        return
+
+    # Determine collection name
+    final_collection = new_collection_name.strip() if is_new_collection else collection_name
+    if not final_collection:
+        final_collection = "General"
+
+    staged = []
+    for file_path in uploaded_files:
+        ext = os.path.splitext(file_path)[-1].lower()
+        if ext in IMAGE_EXTENSIONS:
+            dest = os.path.join(STAGING_DIR, os.path.basename(file_path))
+            shutil.copy2(file_path, dest)
+            staged.append(dest)
+
+    if not staged:
+        yield "No supported images found in upload (jpg, jpeg, png, webp, tiff).", gr.update(), gr.update()
+        return
+
+    yield f"Staging images to collection '{final_collection}'...", gr.update(), gr.update()
+
+    try:
+        for processed, total, msg in ingest_folder(STAGING_DIR, collection=final_collection):
+            if total > 0:
+                pct = int(processed / total * 100)
+                yield f"[{processed}/{total}] ({pct}%) {msg}", gr.update(), gr.update()
+            else:
+                yield msg, gr.update(), gr.update()
+        
+        rows, _ = load_caption_browser()
+        cols = gr.Dropdown(choices=get_all_collections(), value=final_collection)
+        yield f"✅ Done. Ingested to '{final_collection}'. Store has {entry_count()} images.", rows, cols
+    except ValueError as e:
+        yield f"Error: {e}", gr.update(), gr.update()
+
+
+def _parse_meta(raw: str) -> dict | None:
+    """Try to parse raw caption as JSON, with comma-fix fallback."""
+    import re
+    try:
+        return json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        pass
+    try:
+        fixed = re.sub(r'"\s*\n(\s*")', r'",\n\1', raw)
+        return json.loads(fixed)
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
+def load_caption_browser():
+    entries = all_entries()
+    if not entries:
+        return [], "No captions yet."
+    rows = []
+    for path, data in entries.items():
+        raw = data["caption"]
+        meta = _parse_meta(raw)
+        if meta:
+            summary = meta.get("summary") or "—"
+            subj = meta.get("subjects", {})
+            attire = ", ".join(subj.get("attire", [])) or "—"
+            tags = ", ".join(meta.get("search_tags", [])) or "—"
+        else:
+            summary = raw[:300] if raw else "—"
+            attire = "—"
+            tags = "—"
+        rows.append([os.path.basename(path), summary, attire, tags])
+    return rows, f"{len(rows)} caption(s) in store."
+
+
+def run_search(query: str, collection: str = "All"):
+    if not query or not query.strip():
+        return [], "Please enter a search query."
+    if entry_count() == 0:
+        return [], "No images indexed yet. Upload and ingest some photos first."
+    
+    col_filter = None if collection == "All" else collection
+    results = search(query.strip(), collection=col_filter)
+    
+    if not results:
+        return [], f"No matching photos found in {collection} (threshold: {MIN_RELEVANCE})."
+    gallery_items = [
+        (r["path"], f"Score: {r['score']:.2f} — {r['caption'][:120]}…")
+        for r in results
+    ]
+    return gallery_items, f"{len(results)} result(s) found."
+
+
+def load_collections_view(collection_name):
+    if not collection_name or collection_name == "All":
+        entries = all_entries()
+    else:
+        entries = get_entries_by_collection(collection_name)
+    
+    if not entries:
+        return [], f"No images in collection '{collection_name}'."
+    
+    gallery_items = [(path, os.path.basename(path)) for path in entries.keys()]
+    return gallery_items, f"{len(entries)} image(s) in '{collection_name}'."
+
+
+ABOUT_TEXT = """
+## ShutterSearch
+
+A local-first photo search tool powered by **MiniCPM-V-4.6** (≤7B VLM).
+
+**How it works:**
+1. Upload photos using the Ingest page — select an existing collection or create a new one.
+   The VLM runs on Modal's GPU and generates rich captions. Captions are cached locally.
+2. Use the Search page to find photos by content, mood, or composition using natural language.
+3. Browse your organized archive in the Collections page.
+
+Built for the Hugging Face [Build Small](https://huggingface.co/build-small) hackathon.
+"""
+
+
+# --- UI Layout ---
+with gr.Blocks() as demo:
+    # Navigation state
+    current_page = gr.State("home")
+
+    with gr.Sidebar():
+        gr.Markdown("# 📷 ShutterSearch")
+        gr.Markdown("Modern Photo Archive")
+        nav_home = gr.Button("🏠 Home", variant="ghost", size="lg")
+        nav_ingest = gr.Button("📥 Ingest", variant="ghost", size="lg")
+        nav_search = gr.Button("🔍 Search", variant="ghost", size="lg")
+        nav_collections = gr.Button("📁 Collections", variant="ghost", size="lg")
+        nav_captions = gr.Button("📝 Captions", variant="ghost", size="lg")
+        nav_about = gr.Button("ℹ️ About", variant="ghost", size="lg")
+        
+        gr.HTML("<hr>")
+        stats = gr.Label(value=f"Total Photos: {entry_count()}", label="Archive Stats")
+
+    # --- Pages ---
+    with gr.Column() as home_page:
+        with gr.Row():
+            with gr.Column(scale=2):
+                gr.Markdown("""
+                # Welcome to ShutterSearch
+                ### Your intelligent local-first photo archive.
+                
+                ShutterSearch uses state-of-the-art vision models to understand your photography. 
+                Keep your photos organized in collections and find them instantly with natural language search.
+                
+                - **Semantic Search**: Find "sunset on a beach" even if you didn't tag it.
+                - **Automatic Captioning**: Powered by MiniCPM-V-4.6.
+                - **Privacy First**: Everything runs on your terms.
+                """)
+                start_btn = gr.Button("Start Ingesting", variant="primary", size="lg")
+            with gr.Column(scale=1):
+                # Placeholder for random image
+                gr.Image("https://images.unsplash.com/photo-1542038784456-1ea8e935640e?q=80&w=1000&auto=format&fit=crop", 
+                         label="Photography", show_label=False, interactive=False)
+
+    with gr.Column(visible=False) as ingest_page:
+        gr.Markdown("# 📥 Ingest Photos")
+        with gr.Row():
+            with gr.Column(scale=2):
+                upload = gr.File(
+                    label="Upload Images",
+                    file_count="multiple",
+                    file_types=[".jpg", ".jpeg", ".png", ".webp", ".tiff"],
+                    height=300,
+                )
+            with gr.Column(scale=1):
+                gr.Markdown("### Collection Settings")
+                coll_dropdown = gr.Dropdown(
+                    choices=get_all_collections(), 
+                    label="Select Existing Collection",
+                    value="General"
+                )
+                use_new_coll = gr.Checkbox(label="Create New Collection", value=False)
+                new_coll_name = gr.Textbox(label="New Collection Name", visible=False)
+                
+                ingest_btn = gr.Button("🚀 Start Ingestion", variant="primary", size="lg")
+        
+        ingest_status = gr.Textbox(label="Status", interactive=False, lines=5)
+
+    with gr.Column(visible=False) as search_page:
+        gr.Markdown("# 🔍 AI Search")
+        with gr.Row():
+            search_query = gr.Textbox(
+                placeholder="Describe what you're looking for... (e.g. 'moody forest portrait')",
+                label="Search Query",
+                scale=4
+            )
+            search_col_filter = gr.Dropdown(
+                choices=["All"] + get_all_collections(),
+                value="All",
+                label="Filter by Collection",
+                scale=1
+            )
+            search_btn = gr.Button("Search", variant="primary", scale=1)
+        
+        search_status_msg = gr.Markdown("Enter a query to start searching.")
+        search_gallery = gr.Gallery(label="Search Results", columns=4, height="auto")
+
+    with gr.Column(visible=False) as collections_page:
+        gr.Markdown("# 📁 Collections")
+        with gr.Row():
+            view_coll_selector = gr.Dropdown(
+                choices=get_all_collections(),
+                value=get_all_collections()[0] if get_all_collections() else "General",
+                label="Select Collection to Browse",
+                scale=4
+            )
+            refresh_coll_btn = gr.Button("🔄 Refresh", scale=1)
+        
+        coll_status = gr.Markdown("Browse your organized photos.")
+        coll_gallery = gr.Gallery(label="Collection Photos", columns=5, height="auto")
+
+    with gr.Column(visible=False) as captions_page:
+        gr.Markdown("# 📝 Caption Browser")
+        with gr.Row():
+            refresh_cap_btn = gr.Button("🔄 Refresh Data", variant="secondary")
+            cap_status = gr.Textbox(interactive=False, show_label=False, scale=4)
+            
+        caption_table = gr.Dataframe(
+            headers=["File", "Summary", "Attire", "Tags"],
+            datatype=["str", "str", "str", "str"],
+            wrap=True,
+            interactive=False,
+            column_widths=["15%", "45%", "20%", "20%"],
+        )
+
+    with gr.Column(visible=False) as about_page:
+        gr.Markdown("# ℹ️ About ShutterSearch")
+        gr.Markdown(ABOUT_TEXT)
+
+    # --- Navigation Logic ---
+    pages = [home_page, ingest_page, search_page, collections_page, captions_page, about_page]
+    
+    def switch_page(page_name):
+        updates = [gr.update(visible=(name == page_name)) for name in ["home", "ingest", "search", "collections", "captions", "about"]]
+        return updates
+
+    nav_home.click(fn=lambda: switch_page("home"), outputs=pages)
+    nav_ingest.click(fn=lambda: switch_page("ingest"), outputs=pages)
+    nav_search.click(fn=lambda: switch_page("search") + [gr.update(choices=["All"] + get_all_collections())], outputs=pages + [search_col_filter])
+    nav_collections.click(fn=lambda: switch_page("collections") + [gr.update(choices=get_all_collections())], outputs=pages + [view_coll_selector])
+    nav_captions.click(fn=lambda: switch_page("captions"), outputs=pages)
+    nav_about.click(fn=lambda: switch_page("about"), outputs=pages)
+    
+    start_btn.click(fn=lambda: switch_page("ingest"), outputs=pages)
+
+    # --- Page Interactions ---
+    use_new_coll.change(fn=lambda x: gr.update(visible=x), inputs=use_new_coll, outputs=new_coll_name)
+    
+    ingest_btn.click(
+        fn=run_ingest, 
+        inputs=[upload, coll_dropdown, use_new_coll, new_coll_name], 
+        outputs=[ingest_status, caption_table, coll_dropdown]
+    ).then(
+        fn=lambda: f"Total Photos: {entry_count()}", outputs=stats
+    )
+
+    search_btn.click(fn=run_search, inputs=[search_query, search_col_filter], outputs=[search_gallery, search_status_msg])
+    search_query.submit(fn=run_search, inputs=[search_query, search_col_filter], outputs=[search_gallery, search_status_msg])
+
+    view_coll_selector.change(fn=load_collections_view, inputs=view_coll_selector, outputs=[coll_gallery, coll_status])
+    refresh_coll_btn.click(fn=load_collections_view, inputs=view_coll_selector, outputs=[coll_gallery, coll_status])
+
+    refresh_cap_btn.click(fn=load_caption_browser, outputs=[caption_table, cap_status])
+    
+    demo.load(fn=load_caption_browser, outputs=[caption_table, cap_status])
+    demo.load(fn=lambda: load_collections_view(get_all_collections()[0] if get_all_collections() else "General"), outputs=[coll_gallery, coll_status])
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft(primary_hue="green", secondary_hue="emerald"))

caption_store.py

@@ -0,0 +1,182 @@
+"""Persistent caption store backed by a local JSON file."""
+
+import json
+import os
+import time
+from typing import Optional
+
+CAPTION_STORE_PATH = "captions.json"
+
+
+def _load() -> dict:
+    if not os.path.exists(CAPTION_STORE_PATH):
+        return {}
+    with open(CAPTION_STORE_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _save(store: dict) -> None:
+    with open(CAPTION_STORE_PATH, "w", encoding="utf-8") as f:
+        json.dump(store, f, indent=2, ensure_ascii=False)
+
+
+def _as_list(val) -> list:
+    """Ensure a value is always a list — handles string/list/None from model output."""
+    if not val:
+        return []
+    if isinstance(val, list):
+        return val
+    return [val]  # single string → wrap
+
+
+def _try_parse_json(raw: str) -> dict | None:
+    """Parse JSON, with a fallback that inserts missing commas between fields."""
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        pass
+    # Common model mistake: missing comma after a string value before next key
+    import re
+    fixed = re.sub(r'"\s*\n(\s*")', r'",\n\1', raw)
+    try:
+        return json.loads(fixed)
+    except json.JSONDecodeError:
+        return None
+
+
+def flatten_metadata(meta: dict) -> str:
+    parts = []
+
+    if meta.get("summary"):
+        parts.append(meta["summary"])
+
+    subj = meta.get("subjects", {})
+    # NEW: Include headcount explicitly for numerical search queries (e.g., "two people")
+    if subj.get("people_count") is not None:
+        parts.append(f"People count: {subj['people_count']}")
+    if _as_list(subj.get("attire")):
+        parts.append("Attire: " + ", ".join(_as_list(subj["attire"])))
+    if _as_list(subj.get("primary_subjects")):
+        parts.append("Subjects: " + ", ".join(_as_list(subj["primary_subjects"])))
+    if _as_list(subj.get("relationships")):
+        parts.append("Relationships: " + ", ".join(_as_list(subj["relationships"])))
+
+    scene = meta.get("scene", {})
+    if scene.get("location_type"):
+        parts.append("Location: " + scene["location_type"])
+    if scene.get("environment"):
+        parts.append("Environment: " + scene["environment"])
+    if _as_list(scene.get("setting_details")):
+        parts.append("Setting: " + ", ".join(_as_list(scene["setting_details"])))
+
+    actions = meta.get("actions", {})
+    if actions.get("primary_action"):
+        parts.append("Action: " + actions["primary_action"])
+    if _as_list(actions.get("body_language")):
+        parts.append("Body language: " + ", ".join(_as_list(actions["body_language"])))
+
+    lighting = meta.get("lighting", {})
+    if lighting.get("lighting_style"):
+        parts.append("Lighting: " + lighting["lighting_style"])
+    if lighting.get("time_of_day_estimate"):
+        parts.append("Time of day: " + lighting["time_of_day_estimate"])
+
+    mood = meta.get("mood", {})
+    if _as_list(mood.get("primary_emotions")):
+        parts.append("Emotions: " + ", ".join(_as_list(mood["primary_emotions"])))
+    if mood.get("atmosphere"):
+        parts.append("Atmosphere: " + mood["atmosphere"])
+
+    comp = meta.get("composition", {})
+    if comp.get("shot_type"):
+        parts.append("Shot: " + comp["shot_type"])
+    if comp.get("camera_angle"):
+        parts.append("Angle: " + comp["camera_angle"])
+
+    tech = meta.get("technical_cues", {})
+    if _as_list(tech.get("color_palette")):
+        parts.append("Colors: " + ", ".join(_as_list(tech["color_palette"])))
+    # NEW: Missing depth of field (crucial for portrait photography search!)
+    if tech.get("depth_of_field"):
+        parts.append("Depth of field: " + tech["depth_of_field"])
+
+    if _as_list(meta.get("search_tags")):
+        parts.append("Tags: " + ", ".join(_as_list(meta["search_tags"])))
+    if _as_list(meta.get("archive_keywords")):
+        parts.append("Keywords: " + ", ".join(_as_list(meta["archive_keywords"])))
+
+    return " | ".join(parts)
+
+
+def get_entry(image_path: str) -> Optional[dict]:
+    return _load().get(image_path)
+
+
+def upsert_entry(image_path: str, caption: str, mtime: float, collection: str = "General") -> None:
+    """
+    caption may be raw JSON string (new structured format) or plain text (legacy).
+    We store both the raw string and a flattened search_text.
+    """
+    store = _load()
+
+    # Try to parse as structured JSON (with comma-fix fallback)
+    search_text = caption
+    meta = _try_parse_json(caption)
+    if meta:
+        search_text = flatten_metadata(meta)
+
+    store[image_path] = {
+        "caption": caption,        # raw (JSON string or plain text)
+        "search_text": search_text,  # flattened for embedding
+        "mtime": mtime,
+        "collection": collection,
+        "ingested_at": time.time(),
+    }
+    _save(store)
+
+
+def mark_error(image_path: str, error: str, collection: str = "General") -> None:
+    store = _load()
+    store[image_path] = {
+        "caption": None,
+        "error": error,
+        "mtime": os.path.getmtime(image_path) if os.path.exists(image_path) else 0,
+        "collection": collection,
+        "ingested_at": time.time(),
+    }
+    _save(store)
+
+
+def all_entries() -> dict:
+    """Return only entries that have a valid caption."""
+    return {
+        path: data
+        for path, data in _load().items()
+        if data.get("caption")
+    }
+
+
+def entry_count() -> int:
+    return len(all_entries())
+
+
+def get_all_collections() -> list[str]:
+    """Return a sorted list of all unique collection names."""
+    store = _load()
+    collections = set()
+    for entry in store.values():
+        coll = entry.get("collection")
+        if coll:
+            collections.add(coll)
+    if not collections:
+        return ["General"]
+    return sorted(list(collections))
+
+
+def get_entries_by_collection(collection: str) -> dict:
+    """Return all valid entries belonging to a specific collection."""
+    return {
+        path: data
+        for path, data in all_entries().items()
+        if data.get("collection") == collection
+    }

captions.json

@@ -0,0 +1,32 @@
+{
+  "C:\\Users\\swika\\AppData\\Local\\Temp\\photographers_archive_uploads\\aastha-bansal-W1wkx5kcaBk-unsplash.jpg": {
+    "caption": "{\n  \"summary\": \"A couple dressed in traditional wedding attire is posing closely together, with the man in a richly embroidered robe and turban and the woman in elaborate jewelry and a detailed lehenga. The scene is illuminated with focused lighting against a dark background.\",\n  \"subjects\": {\n    \"people_count\": 2,\n    \"primary_subjects\": [\n      \"groom\",\n      \"bride\"\n    ],\n    \"relationships\": [\n      \"couple\"\n    ]\n  },\n  \"attire\": [\n    \"richly embroidered maroon and cream robe with gold detailing\",\n    \"gold and black embellished lehenga with sheer pink overlay\",\n    \"red turban with white feather and ornate jewelry\",\n    \"gold headpiece and heavy jewelry on the bride\"\n  ],\n  \"scene\": {\n    \"location_type\": \"outdoor event\",\n    \"environment\": \"nighttime with dark background and artificial lighting\",\n    \"setting_details\": []\n  },\n  \"actions\": {\n    \"primary_action\": \"posing and embracing\",\n    \"body_language\": [\n      \"close embrace\",\n      \"smiling\",\n      \"hand on shoulder\"\n    ]\n  },\n  \"lighting\": {\n    \"lighting_style\": \"focused spotlight with dark background\",\n    \"time_of_day_estimate\": \"night\"\n  },\n  \"composition\": {\n    \"shot_type\": \"portrait\",\n    \"camera_angle\": \"medium shot, slightly angled\"\n  },\n  \"mood\": {\n    \"primary_emotions\": [\n      \"love\",\n      \"joy\",\n      \"intimacy\"\n    ],\n    \"atmosphere\": \"festive and elegant\"\n  },\n  \"technical_cues\": {\n    \"color_palette\": [\n      \"rich reds\",\n      \"gold accents\",\n      \"dark backgrounds\",\n      \"soft pinks and whites\"\n    ],\n    \"depth_of_field\": \"deep focus on the subjects with blurred background\"\n  },\n  \"search_tags\": [\"wedding\", \"marriage\", \"traditional attire\", \"couple\", \"portrait\"],\n  \"archive_keywords\": [\"wedding photos\", \"traditional ceremony\", \"marital celebration\", \"formal attire\"]\n}",
+    "search_text": "A couple dressed in traditional wedding attire is posing closely together, with the man in a richly embroidered robe and turban and the woman in elaborate jewelry and a detailed lehenga. The scene is illuminated with focused lighting against a dark background. | People count: 2 | Subjects: groom, bride | Relationships: couple | Location: outdoor event | Environment: nighttime with dark background and artificial lighting | Action: posing and embracing | Body language: close embrace, smiling, hand on shoulder | Lighting: focused spotlight with dark background | Time of day: night | Emotions: love, joy, intimacy | Atmosphere: festive and elegant | Shot: portrait | Angle: medium shot, slightly angled | Colors: rich reds, gold accents, dark backgrounds, soft pinks and whites | Depth of field: deep focus on the subjects with blurred background | Tags: wedding, marriage, traditional attire, couple, portrait | Keywords: wedding photos, traditional ceremony, marital celebration, formal attire",
+    "mtime": 1781539262.2399652,
+    "ingested_at": 1781539311.3692434
+  },
+  "C:\\Users\\swika\\AppData\\Local\\Temp\\photographers_archive_uploads\\amish-thakkar-EiGfP6DxgN8-unsplash.jpg": {
+    "caption": "{\n  \"summary\": \"The image captures a traditional wedding ritual featuring hands adorned with ornate bangles and henna, holding a flower and leaf arrangement. The focus is on cultural attire and symbolic gestures.\",\n  \"subjects\": {\n    \"people_count\": 2,\n    \"primary_subjects\": [\n      \"groom\",\n      \"bride\"\n    ],\n    \"relationships\": [\n      \"exchange of ritual items\"\n    ]\n  },\n  \"attire\": [\n    \"embroidered traditional clothing with intricate patterns and gold detailing\",\n    \"henna-decorated hands with haki patterns\",\n    \"richly decorated bangles in red, green, and gold\"\n  ],\n  \"scene\": {\n    \"location_type\": \"outdoor wedding setting\",\n    \"environment\": \"green grassy area with soft background\",\n    \"setting_details\": []\n  },\n  \"actions\": {\n    \"primary_action\": \"holding a flower and leaf arrangement\",\n    \"body_language\": [\n      \"gentle offering gesture\",\n      \"hands positioned closely\"\n    ]\n  },\n  \"lighting\": {\n    \"lighting_style\": \"soft natural light\",\n    \"time_of_day_estimate\": \"daytime\"\n  },\n  \"composition\": {\n    \"shot_type\": \"close-up ritual\",\n    \"camera_angle\": \"overhead and slightly angled\"\n  },\n  \"mood\": {\n    \"primary_emotions\": [\n      \"ceremonious\",\n      \"warm\",\n      \"special\"\n    ],\n    \"atmosphere\": \"festive and traditional\"\n  },\n  \"technical_cues\": {\n    \"color_palette\": [\n      \"red, green, gold, and beige\",\n      \"soft green background\"\n    ],\n    \"depth_of_field\": \"shallow depth of field highlighting the hands and flowers\"\n  },\n  \"search_tags\": [\"wedding\", \"tradition\", \"ritual\", \"henna\", \"bangles\", \"couple\"],\n  \"archive_keywords\": [\"marriage\", \"cultural ceremony\", \"traditional attire\", \"wedding ritual\"]\n}",
+    "search_text": "The image captures a traditional wedding ritual featuring hands adorned with ornate bangles and henna, holding a flower and leaf arrangement. The focus is on cultural attire and symbolic gestures. | People count: 2 | Subjects: groom, bride | Relationships: exchange of ritual items | Location: outdoor wedding setting | Environment: green grassy area with soft background | Action: holding a flower and leaf arrangement | Body language: gentle offering gesture, hands positioned closely | Lighting: soft natural light | Time of day: daytime | Emotions: ceremonious, warm, special | Atmosphere: festive and traditional | Shot: close-up ritual | Angle: overhead and slightly angled | Colors: red, green, gold, and beige, soft green background | Depth of field: shallow depth of field highlighting the hands and flowers | Tags: wedding, tradition, ritual, henna, bangles, couple | Keywords: marriage, cultural ceremony, traditional attire, wedding ritual",
+    "mtime": 1781537948.9068933,
+    "ingested_at": 1781539332.2572837
+  },
+  "C:\\Users\\swika\\AppData\\Local\\Temp\\photographers_archive_uploads\\amish-thakkar-lAY2TAhN06k-unsplash.jpg": {
+    "caption": "{\n  \"summary\": \"A bride in traditional red and gold attire is receiving a decorative element from an adult, with floral and ornate background elements enhancing the ceremonial setting.\"\n  \"subjects\": {\n    \"people_count\": 2,\n    \"primary_subjects\": [\n      \"bride\",\n      \"adult assisting\"\n    ],\n    \"relationships\": [\n      \"bride receiving a decorative item\"\n    ]\n  },\n  \"attire\": [\n    \"rich red bridal gown with gold embroidery\",\n    \"delicate sheer veil with red and gold patterns\",\n    \"gold jewelry including necklace, earrings, and headpiece\",\n    \"pink rose and baby's breath garland\"\n  ],\n  \"scene\": {\n    \"location_type\": \"wedding venue\",\n    \"environment\": \"festive and ornate\",\n    \"setting_details\": [\"white floral arrangements\", \"gold decorative backdrop\"]\n  },\n  \"actions\": {\n    \"primary_action\": \"adjusting or placing a decorative element on the bride's head\",\n    \"body_language\": [\n      \"bride smiling, closed eyes\",\n      \"adult hand gently placing item\"\n    ]\n  },\n  \"lighting\": {\n    \"lighting_style\": \"soft and warm\",\n    \"time_of_day_estimate\": \"indoor celebration\"\n  },\n  \"composition\": {\n    \"shot_type\": \"close-up portrait\",\n    \"camera_angle\": \"low angle, focusing on the bride's face and attire\"\n  },\n  \"mood\": {\n    \"primary_emotions\": [\n      \"joy\",\n      \"delicacy\",\n      \"celebration\"\n    ],\n    \"atmosphere\": \"festive and elegant\"\n  },\n  \"technical_cues\": {\n    \"color_palette\": [\n      \"red and gold\",\n      \"white and pink\",\n      \"gold accents\"\n    ],\n    \"depth_of_field\": \"shallow depth of field with blurred floral background\"\n  },\n  \"search_tags\": [\"bride\", \"wedding\", \"traditional\", \"jewelry\", \"flowers\"],\n  \"archive_keywords\": [\"marriage\", \"cultural attire\", \"wedding ceremony\", \"bride's dress\", \"traditional decor\"]\n}",
+    "search_text": "A bride in traditional red and gold attire is receiving a decorative element from an adult, with floral and ornate background elements enhancing the ceremonial setting. | People count: 2 | Subjects: bride, adult assisting | Relationships: bride receiving a decorative item | Location: wedding venue | Environment: festive and ornate | Setting: white floral arrangements, gold decorative backdrop | Action: adjusting or placing a decorative element on the bride's head | Body language: bride smiling, closed eyes, adult hand gently placing item | Lighting: soft and warm | Time of day: indoor celebration | Emotions: joy, delicacy, celebration | Atmosphere: festive and elegant | Shot: close-up portrait | Angle: low angle, focusing on the bride's face and attire | Colors: red and gold, white and pink, gold accents | Depth of field: shallow depth of field with blurred floral background | Tags: bride, wedding, traditional, jewelry, flowers | Keywords: marriage, cultural attire, wedding ceremony, bride's dress, traditional decor",
+    "mtime": 1781539262.1515195,
+    "ingested_at": 1781539353.038621
+  },
+  "C:\\Users\\swika\\AppData\\Local\\Temp\\photographers_archive_uploads\\amish-thakkkar-EiGfP6DxgN8-unsplash.jpg": {
+    "caption": "{\n  \"summary\": \"The image captures a traditional wedding ritual featuring hands adorned with ornate bangles and henna, holding a flower and leaf arrangement. The focus is on cultural attire and symbolic gestures.\",\n  \"subjects\": {\n    \"people_count\": 2,\n    \"primary_subjects\": [\n      \"groom\",\n      \"bride\"\n    ],\n    \"relationships\": [\n      \"exchange of ritual items\"\n    ]\n  },\n  \"attire\": [\n    \"embroidered traditional clothing with intricate patterns and gold detailing\",\n    \"henna-decorated hands with haki patterns\",\n    \"richly decorated bangles in red, green, and gold\"\n  ],\n  \"scene\": {\n    \"location_type\": \"outdoor wedding setting\",\n    \"environment\": \"green grassy area with soft background\",\n    \"setting_details\": []\n  },\n  \"actions\": {\n    \"primary_action\": \"holding a flower and leaf arrangement\",\n    \"body_language\": [\n      \"gentle offering gesture\",\n      \"hands positioned closely\"\n    ]\n  },\n  \"lighting\": {\n    \"lighting_style\": \"soft natural light\",\n    \"time_of_day_estimate\": \"daytime\"\n  },\n  \"composition\": {\n    \"shot_type\": \"close-up ritual\",\n    \"camera_angle\": \"overhead and slightly angled\"\n  },\n  \"mood\": {\n    \"primary_emotions\": [\n      \"ceremonious\",\n      \"warm\",\n      \"special\"\n    ],\n    \"atmosphere\": \"festive and traditional\"\n  },\n  \"technical_cues\": {\n    \"color_palette\": [\n      \"red, green, gold, and beige\",\n      \"soft green background\"\n    ],\n    \"depth_of_field\": \"shallow depth of field highlighting the hands and flowers\"\n  },\n  \"search_tags\": [\"wedding\", \"tradition\", \"ritual\", \"henna\", \"bangles\", \"couple\"],\n  \"archive_keywords\": [\"marriage\", \"cultural ceremony\", \"traditional attire\", \"wedding ritual\"]\n}",
+    "search_text": "The image captures a traditional wedding ritual featuring hands adorned with ornate bangles and henna, holding a flower and leaf arrangement. The focus is on cultural attire and symbolic gestures. | People count: 2 | Subjects: groom, bride | Relationships: exchange of ritual items | Location: outdoor wedding setting | Environment: green grassy area with soft background | Action: holding a flower and leaf arrangement | Body language: gentle offering gesture, hands positioned closely | Lighting: soft natural light | Time of day: daytime | Emotions: ceremonious, warm, special | Atmosphere: festive and traditional | Shot: close-up ritual | Angle: overhead and slightly angled | Colors: red, green, gold, and beige, soft green background | Depth of field: shallow depth of field highlighting the hands and flowers | Tags: wedding, tradition, ritual, henna, bangles, couple | Keywords: marriage, cultural ceremony, traditional attire, wedding ritual",
+    "mtime": 1781539262.1897466,
+    "ingested_at": 1781539373.021067
+  },
+  "C:\\Users\\swika\\AppData\\Local\\Temp\\photographers_archive_uploads\\arto-suraj-Y3QEAct9JT4-unsplash.jpg": {
+    "caption": "{\n  \"summary\": \"A couple is posing for a wedding portrait, with the woman in a rich red embroidered gown and the man in a light pink traditional suit. The background is adorned with warm bokeh lights, suggesting an evening event.\"\n  \"subjects\": {\n    \"people_count\": 2,\n    \"primary_subjects\": [\n      \"bride\",\n      \"groom\"\n    ],\n    \"relationships\": [\n      \"couple\"\n    ]\n  },\n  \"attire\": [\n    \"bride: red embroidered lehenga with gold embellishments and jewelry\",\n    \"groom: light pink textured sherwani with pearl necklaces and a pink turban\"\n  ],\n  \"scene\": {\n    \"location_type\": \"outdoor or event space\",\n    \"environment\": \"nighttime with decorative string lights\",\n    \"setting_details\": []\n  },\n  \"actions\": {\n    \"primary_action\": \"posing for a wedding portrait\",\n    \"body_language\": [\n      \"smiling\",\n      \"hands clasped\",\n      \"touching each other's shoulders\"\n    ]\n  },\n  \"lighting\": {\n    \"lighting_style\": \"soft artificial lighting with bokeh background\",\n    \"time_of_day_estimate\": \"night\"\n  },\n  \"composition\": {\n    \"shot_type\": \"portrait\",\n    \"camera_angle\": \"eye level\"\n  },\n  \"mood\": {\n    \"primary_emotions\": [\n      \"happy\",\n      \"celebratory\"\n    ],\n    \"atmosphere\": \"festive and elegant\"\n  },\n  \"technical_cues\": {\n    \"color_palette\": [\n      \"red and pink\",\n      \"gold and white\",\n      \"dark background with warm lights\"\n    ],\n    \"depth_of_field\": \"shallow depth of field highlighting subjects\"\n  },\n  \"search_tags\": [\"wedding\", \"bride\", \"groom\", \"tradition\", \"event\"],\n  \"archive_keywords\": [\"marriage\", \"couple\", \"wedding portrait\", \"traditional attire\", \"nighttime\"]\n}",
+    "search_text": "A couple is posing for a wedding portrait, with the woman in a rich red embroidered gown and the man in a light pink traditional suit. The background is adorned with warm bokeh lights, suggesting an evening event. | People count: 2 | Subjects: bride, groom | Relationships: couple | Location: outdoor or event space | Environment: nighttime with decorative string lights | Action: posing for a wedding portrait | Body language: smiling, hands clasped, touching each other's shoulders | Lighting: soft artificial lighting with bokeh background | Time of day: night | Emotions: happy, celebratory | Atmosphere: festive and elegant | Shot: portrait | Angle: eye level | Colors: red and pink, gold and white, dark background with warm lights | Depth of field: shallow depth of field highlighting subjects | Tags: wedding, bride, groom, tradition, event | Keywords: marriage, couple, wedding portrait, traditional attire, nighttime",
+    "mtime": 1781539262.1016433,
+    "ingested_at": 1781539392.780786
+  }
+}

ingest.py

@@ -0,0 +1,74 @@
+"""Photo ingestion: scan folder, caption new/changed images via Modal."""
+
+import logging
+import os
+from pathlib import Path
+from typing import Generator
+
+from caption_store import get_entry, mark_error, upsert_entry
+
+logger = logging.getLogger(__name__)
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".tiff"}
+
+
+def scan_images(folder: str) -> list[str]:
+    folder_path = Path(folder)
+    if not folder_path.exists() or not folder_path.is_dir():
+        raise ValueError(f"Folder not found or not readable: {folder}")
+    return [
+        str(p)
+        for p in folder_path.rglob("*")
+        if p.suffix.lower() in IMAGE_EXTENSIONS and p.is_file()
+    ]
+
+
+def _needs_captioning(image_path: str) -> bool:
+    entry = get_entry(image_path)
+    if entry is None:
+        return True
+    return os.path.getmtime(image_path) != entry.get("mtime", -1)
+
+
+def _get_captioner():
+    """Return a handle to the deployed Modal Captioner."""
+    import modal
+    Captioner = modal.Cls.from_name("photographers-archive", "Captioner")
+    return Captioner()
+
+
+def ingest_folder(folder: str, collection: str = "General") -> Generator[tuple[int, int, str], None, None]:
+    """
+    Yields (processed_count, total_count, status_message) during ingestion.
+    Raises ValueError for invalid folder paths.
+    """
+    images = scan_images(folder)
+    total = len(images)
+
+    if total == 0:
+        yield (0, 0, "No supported images found in the selected folder.")
+        return
+
+    captioner = _get_captioner()
+    processed = 0
+
+    for image_path in images:
+        if not _needs_captioning(image_path):
+            processed += 1
+            yield (processed, total, f"Skipped (cached): {os.path.basename(image_path)}")
+            continue
+
+        try:
+            with open(image_path, "rb") as f:
+                image_bytes = f.read()
+            caption = captioner.caption.remote(image_bytes, os.path.basename(image_path))
+            upsert_entry(image_path, caption, os.path.getmtime(image_path), collection=collection)
+            processed += 1
+            yield (processed, total, f"Captioned: {os.path.basename(image_path)}")
+        except Exception as e:
+            logger.error("Failed to caption %s: %s", image_path, e)
+            mark_error(image_path, str(e), collection=collection)
+            processed += 1
+            yield (processed, total, f"Error: {os.path.basename(image_path)}")
+
+    yield (total, total, f"Done. {total} images processed.")

logic.py

@@ -0,0 +1,376 @@
+# import json
+# import logging
+# import os
+# import re
+# import shutil
+# import tempfile
+# import gradio as gr
+
+# from caption_store import all_entries, entry_count, get_all_collections, get_entries_by_collection
+# from ingest import ingest_folder
+# from search import MIN_RELEVANCE, search
+
+# logging.basicConfig(level=logging.INFO)
+
+# IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".tiff"}
+# STAGING_DIR = os.path.join(tempfile.gettempdir(), "photographers_archive_uploads")
+# os.makedirs(STAGING_DIR, exist_ok=True)
+
+
+# def run_ingest(uploaded_files, collection_name, is_new_collection, new_collection_name):
+#     """
+#     Clears the staging directory, moves uploaded images, validates the destination
+#     collection, and runs the vision-model ingestion process.
+#     """
+#     if not uploaded_files:
+#         yield "⚠️ Please upload at least one image to begin.", gr.update(), gr.update()
+#         return
+
+#     # 1. Determine and validate collection selection context
+#     if is_new_collection:
+#         final_collection = new_collection_name.strip()
+#         if not final_collection:
+#             yield "⚠️ Ingestion halted: Please specify a valid name for the new collection.", gr.update(), gr.update()
+#             return
+#     else:
+#         final_collection = collection_name
+#         if not final_collection:
+#             final_collection = "General"
+
+#     # 2. Housekeep staging directory (clear residuals from prior sessions)
+#     try:
+#         for filename in os.listdir(STAGING_DIR):
+#             file_path = os.path.join(STAGING_DIR, filename)
+#             if os.path.isfile(file_path) or os.path.islink(file_path):
+#                 os.unlink(file_path)
+#             elif os.path.isdir(file_path):
+#                 shutil.rmtree(file_path)
+#     except Exception as e:
+#         logging.warning(f"Could not clear staging directory fully: {e}")
+
+#     # 3. Stage files
+#     staged = []
+#     for file_path in uploaded_files:
+#         ext = os.path.splitext(file_path)[-1].lower()
+#         if ext in IMAGE_EXTENSIONS:
+#             dest = os.path.join(STAGING_DIR, os.path.basename(file_path))
+#             shutil.copy2(file_path, dest)
+#             staged.append(dest)
+
+#     if not staged:
+#         yield "⚠️ Format error: No supported images (jpg, jpeg, png, webp, tiff) found.", gr.update(), gr.update()
+#         return
+
+#     yield f"Staging completed. Initializing pipeline for: '{final_collection}'...", gr.update(), gr.update()
+
+#     # 4. Ingest and track progress
+#     try:
+#         for processed, total, msg in ingest_folder(STAGING_DIR, collection=final_collection):
+#             if total > 0:
+#                 pct = int(processed / total * 100)
+#                 yield f">> Progress: [{processed}/{total}] ({pct}%) - {msg}", gr.update(), gr.update()
+#             else:
+#                 yield f">> {msg}", gr.update(), gr.update()
+        
+#         # 5. Fetch updated data and regenerate dropdown choices safely
+#         rows, _ = load_caption_browser()
+#         choices = get_all_collections()
+#         if not choices:
+#             choices = ["General"]
+            
+#         dropdown_val = final_collection if final_collection in choices else choices[0]
+#         cols = gr.Dropdown(choices=choices, value=dropdown_val)
+        
+#         yield f"System Log: Done. Ingested to '{final_collection}'. Store has {entry_count()} images.", rows, cols
+#     except ValueError as e:
+#         yield f"Pipeline Failure: {e}", gr.update(), gr.update()
+
+
+# def _parse_meta(raw: str) -> dict | None:
+#     """Attempts to parse raw metadata caption as JSON with syntax fallback support."""
+#     try:
+#         return json.loads(raw)
+#     except (json.JSONDecodeError, TypeError):
+#         pass
+#     try:
+#         # Fallback fix for missing trailing commas in lists
+#         fixed = re.sub(r'"\s*\n(\s*")', r'",\n\1', raw)
+#         return json.loads(fixed)
+#     except (json.JSONDecodeError, TypeError):
+#         return None
+
+
+# def load_caption_browser():
+#     """Loads all caption entries structured for tabular visualization."""
+#     entries = all_entries()
+#     if not entries:
+#         return [], "No captions index exists yet."
+    
+#     rows = []
+#     for path, data in entries.items():
+#         raw = data["caption"]
+#         meta = _parse_meta(raw)
+#         if meta:
+#             summary = meta.get("summary") or "—"
+#             subj = meta.get("subjects", {})
+#             attire = ", ".join(subj.get("attire", [])) or "—"
+#             tags = ", ".join(meta.get("search_tags", [])) or "—"
+#         else:
+#             summary = raw[:300] if raw else "—"
+#             attire = "—"
+#             tags = "—"
+#         rows.append([os.path.basename(path), summary, attire, tags])
+        
+#     return rows, f"{len(rows)} caption record(s) loaded."
+
+
+# def run_search(query: str, collection: str = "All"):
+#     """Searches indexed captions using natural language match thresholding."""
+#     if not query or not query.strip():
+#         return [], "Please enter a valid search parameter."
+#     if entry_count() == 0:
+#         return [], "No images indexed yet. Please ingest photos first."
+    
+#     col_filter = None if collection == "All" else collection
+#     results = search(query.strip(), collection=col_filter)
+    
+#     if not results:
+#         return [], f"Zero matches in database for target {collection} (Threshold constraint: {MIN_RELEVANCE})."
+        
+#     gallery_items = [
+#         (r["path"], f"Confidence: {r['score']:.2f} | {r['caption'][:120]}…")
+#         for r in results
+#     ]
+#     return gallery_items, f"{len(results)} query match(es) located."
+
+
+# def load_collections_view(collection_name):
+#     """Fetches list of path references sorted within specific collection targets."""
+#     if not collection_name or collection_name == "All":
+#         entries = all_entries()
+#     else:
+#         entries = get_entries_by_collection(collection_name)
+    
+#     if not entries:
+#         return [], f"No stored assets in target collection: '{collection_name}'."
+    
+#     gallery_items = [(path, os.path.basename(path)) for path in entries.keys()]
+#     return gallery_items, f"Found {len(entries)} file reference(s) within '{collection_name}'."
+
+
+# def update_collections_dropdown():
+#     """Returns a safe state package configuration payload for collection selectors."""
+#     choices = get_all_collections()
+#     if not choices:
+#         choices = ["General"]
+#     val = "General" if "General" in choices else choices[0]
+#     return gr.update(choices=choices, value=val)
+
+
+# def update_search_dropdown():
+#     """Returns a safe state package configuration payload for search filter dropdowns."""
+#     choices = ["All"] + get_all_collections()
+#     return gr.update(choices=choices, value="All")
+import hashlib
+import json
+import logging
+import os
+import re
+import shutil
+import tempfile
+import zipfile
+import gradio as gr
+from PIL import Image
+
+from caption_store import all_entries, entry_count, get_all_collections, get_entries_by_collection
+from ingest import ingest_folder
+from search import MIN_RELEVANCE, search
+
+logging.basicConfig(level=logging.INFO)
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".tiff"}
+STAGING_DIR = os.path.join(tempfile.gettempdir(), "photographers_archive_uploads")
+THUMBNAIL_DIR = os.path.join(tempfile.gettempdir(), "photographers_archive_thumbnails")
+
+os.makedirs(STAGING_DIR, exist_ok=True)
+os.makedirs(THUMBNAIL_DIR, exist_ok=True)
+
+
+def get_thumbnail_path(original_path):
+    """Generates and returns a cached lightweight WebP thumbnail path."""
+    path_hash = hashlib.md5(original_path.encode('utf-8')).hexdigest()
+    thumb_path = os.path.join(THUMBNAIL_DIR, f"{path_hash}.webp")
+    
+    if os.path.exists(thumb_path):
+        return thumb_path
+        
+    try:
+        with Image.open(original_path) as img:
+            img.thumbnail((300, 300))
+            img.save(thumb_path, "WEBP", quality=70)
+        return thumb_path
+    except Exception as e:
+        logging.warning(f"Could not render thumbnail for {original_path}: {e}")
+        return original_path
+
+
+def run_ingest(uploaded_files, collection_name, is_new_collection, new_collection_name):
+    if not uploaded_files:
+        yield "⚠️ Please upload at least one image to begin.", gr.update(), gr.update()
+        return
+
+    if is_new_collection:
+        final_collection = new_collection_name.strip()
+        if not final_collection:
+            yield "⚠️ Ingestion halted: Please specify a valid name for the new collection.", gr.update(), gr.update()
+            return
+    else:
+        final_collection = collection_name
+        if not final_collection:
+            final_collection = "General"
+
+    try:
+        for filename in os.listdir(STAGING_DIR):
+            file_path = os.path.join(STAGING_DIR, filename)
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+    except Exception as e:
+        logging.warning(f"Could not clear staging directory fully: {e}")
+
+    staged = []
+    for file_path in uploaded_files:
+        ext = os.path.splitext(file_path)[-1].lower()
+        if ext in IMAGE_EXTENSIONS:
+            dest = os.path.join(STAGING_DIR, os.path.basename(file_path))
+            shutil.copy2(file_path, dest)
+            staged.append(dest)
+
+    if not staged:
+        yield "⚠️ Format error: No supported images (jpg, jpeg, png, webp, tiff) found.", gr.update(), gr.update()
+        return
+
+    yield f"Staging completed. Initializing pipeline for: '{final_collection}'...", gr.update(), gr.update()
+
+    try:
+        for processed, total, msg in ingest_folder(STAGING_DIR, collection=final_collection):
+            if total > 0:
+                pct = int(processed / total * 100)
+                yield f">> Progress: [{processed}/{total}] ({pct}%) - {msg}", gr.update(), gr.update()
+            else:
+                yield f">> {msg}", gr.update(), gr.update()
+        
+        rows, _ = load_caption_browser()
+        choices = get_all_collections()
+        if not choices:
+            choices = ["General"]
+            
+        dropdown_val = final_collection if final_collection in choices else choices[0]
+        cols = gr.Dropdown(choices=choices, value=dropdown_val)
+        
+        yield f"System Log: Done. Ingested to '{final_collection}'. Store has {entry_count()} images.", rows, cols
+    except ValueError as e:
+        yield f"Pipeline Failure: {e}", gr.update(), gr.update()
+
+
+def _parse_meta(raw: str) -> dict | None:
+    try:
+        return json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        pass
+    try:
+        fixed = re.sub(r'"\s*\n(\s*")', r'",\n\1', raw)
+        return json.loads(fixed)
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
+def load_caption_browser():
+    entries = all_entries()
+    if not entries:
+        return [], "No captions index exists yet."
+    
+    rows = []
+    for path, data in entries.items():
+        raw = data["caption"]
+        meta = _parse_meta(raw)
+        if meta:
+            summary = meta.get("summary") or "—"
+            subj = meta.get("subjects", {})
+            attire = ", ".join(subj.get("attire", [])) or "—"
+            tags = ", ".join(meta.get("search_tags", [])) or "—"
+        else:
+            summary = raw[:300] if raw else "—"
+            attire = "—"
+            tags = "—"
+        rows.append([os.path.basename(path), summary, attire, tags])
+        
+    return rows, f"{len(rows)} caption record(s) loaded."
+
+
+def run_search(query: str, collection: str = "All"):
+    """Performs search and outputs thumbnail images, absolute original files, and logs."""
+    if not query or not query.strip():
+        return [], [], "Please enter a valid search parameter."
+    if entry_count() == 0:
+        return [], [], "No images indexed yet. Please ingest photos first."
+    
+    col_filter = None if collection == "All" else collection
+    results = search(query.strip(), collection=col_filter)
+    
+    if not results:
+        return [], [], f"Zero matches in database for target {collection} (Threshold constraint: {MIN_RELEVANCE})."
+        
+    original_paths = [r["path"] for r in results]
+    gallery_items = []
+    for r in results:
+        thumb = get_thumbnail_path(r["path"])
+        gallery_items.append((thumb, os.path.basename(r["path"])))
+        
+    return gallery_items, original_paths, f"Found {len(results)} search matches."
+
+
+def load_collections_view(collection_name):
+    if not collection_name or collection_name == "All":
+        entries = all_entries()
+    else:
+        entries = get_entries_by_collection(collection_name)
+    
+    if not entries:
+        return [], [], f"No stored assets in target collection: '{collection_name}'."
+    
+    original_paths = list(entries.keys())
+    gallery_items = []
+    
+    for path in original_paths:
+        thumb = get_thumbnail_path(path)
+        gallery_items.append((thumb, os.path.basename(path)))
+        
+    return gallery_items, original_paths, f"Found {len(entries)} image(s) within '{collection_name}'."
+
+
+def zip_selected_files(selected_list):
+    if not selected_list:
+        return None, "⚠️ Downloader: Zero images selected."
+    
+    try:
+        temp_zip = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
+        with zipfile.ZipFile(temp_zip.name, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in selected_list:
+                if os.path.exists(file_path):
+                    zipf.write(file_path, os.path.basename(file_path))
+        return temp_zip.name, f"✅ Zip file ready with {len(selected_list)} source file(s)."
+    except Exception as e:
+        return None, f"⚠️ Compression failure: {e}"
+
+
+def update_collections_dropdown():
+    choices = get_all_collections()
+    if not choices:
+        choices = ["General"]
+    val = "General" if "General" in choices else choices[0]
+    return gr.update(choices=choices, value=val)
+
+
+def update_search_dropdown():
+    choices = ["All"] + get_all_collections()
+    return gr.update(choices=choices, value="All")

modal_caption.py

@@ -0,0 +1,167 @@
+"""Modal app: runs MiniCPM-V-4.6 captioning on a remote GPU."""
+
+import modal
+
+app = modal.App("photographers-archive")
+
+image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "transformers[torch]>=5.7.0",
+        "torchvision",
+        "av",
+        "Pillow",
+        "torch>=2.1.0",
+        "accelerate",
+    )
+)
+
+MODEL_ID = "openbmb/MiniCPM-V-4.6"
+
+CAPTION_PROMPT = """You are a wedding and portrait photo archivist. Analyze this image and return ONLY a valid JSON object — no markdown, no explanation, no code fences.
+
+Crucial Prompting Guidelines:
+1. Be highly specific with textures, fabrics, and patterns in "attire" (e.g., "lace wedding gown", "black velvet tuxedo", "pinstripe suit").
+2. Avoid generic descriptions in "summary". Focus on explicit visual facts (who, what, where, explicit actions).
+3. Under "primary_subjects", explicitly label roles if evident (e.g., "bride", "groom", "bridesmaid", "groomsman", "mother of the bride").
+4. For "depth_of_field", specify features like "shallow depth of field", "bokeh background", or "deep focus".
+
+Use this exact schema:
+{
+  "summary": "2-3 sentence description of the scene",
+  "subjects": {
+    "people_count": 0,
+    "primary_subjects": [],
+    "relationships": [],
+    "attire": []
+  },
+  "scene": {
+    "location_type": "",
+    "environment": "",
+    "setting_details": []
+  },
+  "actions": {
+    "primary_action": "",
+    "body_language": []
+  },
+  "lighting": {
+    "lighting_style": "",
+    "time_of_day_estimate": ""
+  },
+  "composition": {
+    "shot_type": "",
+    "camera_angle": ""
+  },
+  "mood": {
+    "primary_emotions": [],
+    "atmosphere": ""
+  },
+  "technical_cues": {
+    "color_palette": [],
+    "depth_of_field": ""
+  },
+  "search_tags": [],
+  "archive_keywords": []
+}"""
+
+# Cache model weights in a Modal Volume so they persist across cold starts
+model_volume = modal.Volume.from_name("minicpm-weights", create_if_missing=True)
+
+
+@app.cls(
+    image=image,
+    gpu="A10G",
+    volumes={"/model-cache": model_volume},
+    timeout=300,
+)
+class Captioner:
+    @modal.enter()
+    def load(self):
+        import torch
+        from transformers import AutoModelForImageTextToText, AutoProcessor
+
+        self.processor = AutoProcessor.from_pretrained(
+            MODEL_ID, cache_dir="/model-cache"
+        )
+        self.model = AutoModelForImageTextToText.from_pretrained(
+            MODEL_ID,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+            cache_dir="/model-cache",
+        )
+
+    @modal.method()
+    def caption(self, image_bytes: bytes, filename: str = "image.jpg") -> str:
+        import json
+        import os
+        import re
+        import tempfile
+        import torch
+
+        suffix = os.path.splitext(filename)[-1] or ".jpg"
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as f:
+            f.write(image_bytes)
+            tmp_path = f.name
+
+        try:
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "image", "url": tmp_path},
+                        {"type": "text", "text": CAPTION_PROMPT},
+                    ],
+                }
+            ]
+
+            inputs = self.processor.apply_chat_template(
+                messages,
+                tokenize=True,
+                add_generation_prompt=True,
+                return_dict=True,
+                return_tensors="pt",
+                downsample_mode="16x",
+                max_slice_nums=9,
+            ).to(self.model.device)
+
+            with torch.inference_mode():
+                generated_ids = self.model.generate(
+                    **inputs,
+                    downsample_mode="16x",
+                    max_new_tokens=2048,
+                    do_sample=False,
+                )
+
+            trimmed = [
+                out_ids[len(in_ids):]
+                for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+            ]
+            raw = self.processor.batch_decode(
+                trimmed,
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=False,
+            )[0].strip()
+
+            # Strip markdown code fences if model added them anyway
+            raw = re.sub(r"^```(?:json)?\s*", "", raw)
+            raw = re.sub(r"\s*```$", "", raw)
+
+            # Validate JSON — if broken, return as plain text so it still gets stored
+            try:
+                json.loads(raw)
+            except json.JSONDecodeError:
+                # Attempt to salvage by extracting the outermost {...} block
+                match = re.search(r"\{.*\}", raw, re.DOTALL)
+                if match:
+                    candidate = match.group(0)
+                    try:
+                        json.loads(candidate)
+                        return candidate
+                    except json.JSONDecodeError:
+                        pass
+                # Give up and return raw — caption_store will treat it as plain text
+                return raw
+
+            return raw
+        finally:
+            os.unlink(tmp_path)

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=5.0.0
+sentence-transformers>=3.0.0
+modal>=0.73.0
+numpy
+Pillow

search.py

@@ -0,0 +1,122 @@
+"""Semantic search with keyword boosting over structured captions."""
+
+from __future__ import annotations
+
+import json
+import re
+
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+from caption_store import all_entries
+
+_embed_model: SentenceTransformer | None = None
+_MODEL_NAME = "BAAI/bge-base-en-v1.5"  # stronger than MiniLM
+
+MIN_RELEVANCE = 0.55
+TOP_K = 20
+
+# Weight given to keyword boost relative to semantic score (0–1 additive)
+KEYWORD_BOOST = 0.3
+
+
+def _get_embed_model() -> SentenceTransformer:
+    global _embed_model
+    if _embed_model is None:
+        _embed_model = SentenceTransformer(_MODEL_NAME)
+    return _embed_model
+
+
+def _query_tokens(query: str) -> list[str]:
+    """Lowercase words from query, 3+ chars."""
+    return [w for w in re.findall(r"\b\w+\b", query.lower()) if len(w) >= 3]
+
+
+def _keyword_score(query_tokens: list[str], search_text: str, raw_caption: str) -> float:
+    if not query_tokens:
+        return 0.0
+
+    # Tokenize the target text strictly by word boundaries to avoid partial substring hits
+    target_words = set(re.findall(r"\b\w+\b", search_text.lower()))
+    
+    # Calculate regular hits
+    hits = sum(1 for token in query_tokens if token in target_words)
+    
+    # Extra weight for specific high-signal fields (attire, keywords, tags)
+    high_signal_words = set()
+    try:
+        meta = json.loads(raw_caption)
+        # Gather arrays that explicitly hold high-intent search terms
+        for field in [meta.get("search_tags", []), meta.get("archive_keywords", []), meta.get("subjects", {}).get("attire", [])]:
+            if isinstance(field, list):
+                for item in field:
+                    high_signal_words.update(re.findall(r"\b\w+\b", str(item).lower()))
+            elif isinstance(field, str):
+                high_signal_words.update(re.findall(r"\b\w+\b", field.lower()))
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+    high_signal_hits = sum(1 for token in query_tokens if token in high_signal_words)
+
+    # Instead of penalizing long queries, reward ANY valid keyword match heavily
+    if hits == 0:
+        return 0.0
+        
+    base_score = hits / len(query_tokens)
+    boost_bonus = 0.5 if high_signal_hits > 0 else 0.0
+    
+    return min(base_score + boost_bonus, 1.0)
+
+
+def search(query: str, collection: str | None = None) -> list[dict]:
+    """
+    Hybrid search: semantic similarity + keyword boost on structured fields.
+    Returns up to TOP_K results with score >= MIN_RELEVANCE.
+    """
+    all_indexed = all_entries()
+    if not all_indexed:
+        return []
+
+    # Filter by collection if specified
+    if collection and collection != "All":
+        entries = {
+            p: data for p, data in all_indexed.items()
+            if data.get("collection") == collection
+        }
+    else:
+        entries = all_indexed
+
+    if not entries:
+        return []
+
+    model = _get_embed_model()
+    query_tokens = _query_tokens(query)
+
+    paths = list(entries.keys())
+    search_texts = [entries[p].get("search_text") or entries[p]["caption"] for p in paths]
+    raw_captions = [entries[p]["caption"] for p in paths]
+
+    # Query side gets an explicit instruction prefix
+    query_text = f"Represent this sentence for searching relevant passages: {query}"
+    query_vec = model.encode([query_text], normalize_embeddings=True)
+
+    # Document side stays normal
+    caption_vecs = model.encode(search_texts, normalize_embeddings=True)
+    semantic_scores = (caption_vecs @ query_vec.T).flatten()
+
+    final_scores = []
+    for i, (sem, st, rc) in enumerate(zip(semantic_scores, search_texts, raw_captions)):
+        kw = _keyword_score(query_tokens, st, rc)
+        final_scores.append(float(sem) + KEYWORD_BOOST * kw)
+
+    ranked = sorted(
+        zip(paths, search_texts, final_scores),
+        key=lambda x: x[2],
+        reverse=True,
+    )
+
+    return [
+        {"path": p, "caption": c, "score": round(s, 4)}
+        for p, c, s in ranked[:TOP_K]
+        if s >= MIN_RELEVANCE
+    ]

style.css

@@ -0,0 +1,269 @@
+/* Sidebar Container */
+#custom-sidebar {
+    background-color: #0f172a !important;
+    /* Deep Slate 900 */
+    border-right: 1px solid #1e293b !important;
+    /* Slate 800 */
+    padding: 24px 16px !important;
+    display: flex;
+    flex-direction: column;
+    height: 100vh !important;
+    /* Ensures it spans full viewport height */
+    box-shadow: 4px 0 24px rgba(0, 0, 0, 0.3) !important;
+}
+
+/* App Brand Header */
+.brand-header {
+    margin-bottom: 32px;
+    padding-left: 12px;
+    border-bottom: 1px solid #1e293b;
+    padding-bottom: 20px;
+}
+
+.brand-header h1 {
+    font-size: 1.6rem !important;
+    font-weight: 800 !important;
+    background: linear-gradient(135deg, #f8fafc 0%, #94a3b8 100%);
+    /* Subtle gradient */
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin-bottom: 6px !important;
+    letter-spacing: -0.5px;
+}
+
+.brand-header p {
+    font-size: 0.7rem;
+    color: #64748b;
+    /* Slate 500 */
+    text-transform: uppercase;
+    letter-spacing: 1.5px;
+    font-weight: 600;
+    margin: 0;
+}
+
+/* Modern Navigation Buttons */
+.nav-btn {
+    text-align: left !important;
+    justify-content: flex-start !important;
+    background: transparent !important;
+    border: 1px solid transparent !important;
+    box-shadow: none !important;
+    color: #94a3b8 !important;
+    /* Slate 400 */
+    font-weight: 500 !important;
+    font-size: 0.95rem !important;
+    padding: 10px 16px !important;
+    border-radius: 10px !important;
+    transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    /* Smooth easing */
+    margin-bottom: 8px !important;
+    display: flex !important;
+    align-items: center !important;
+    gap: 10px !important;
+    /* Perfect emoji/text alignment */
+}
+
+.nav-btn:hover {
+    background-color: #1e293b !important;
+    /* Slate 800 */
+    color: #f8fafc !important;
+    /* Slate 50 */
+    border-color: #334155 !important;
+    /* Slate 700 */
+    transform: translateX(4px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2) !important;
+}
+
+.nav-btn:active {
+    transform: translateX(2px) scale(0.98);
+    /* Subtle click feedback */
+}
+
+.stats-container .svelte-1b6s6s {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    margin: 0 !important;
+    font-size: 1rem !important;
+}
+
+/* Main Content Area (Dark Theme Match) */
+.main-content {
+    padding: 32px 48px;
+    max-width: 1200px;
+    margin: 0 auto;
+    background-color: #020617 !important;
+    /* Slate 950 (slightly darker than sidebar) */
+    color: #e2e8f0 !important;
+    min-height: 100vh;
+}
+
+
+
+/* Dark Settings Card */
+.settings-card {
+    background-color: #1e293b !important;
+    /* Surface level 1 */
+    border: 1px solid #334155 !important;
+    /* Dark Slate Border */
+    border-radius: 12px !important;
+    padding: 24px !important;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.3) !important;
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+}
+
+.settings-card h3 {
+    margin-top: 0 !important;
+    font-size: 1.1rem !important;
+    color: #f8fafc !important;
+    font-weight: 600 !important;
+}
+
+/* Customize Upload Area */
+.upload-zone {
+    border: 2px dashed #475569 !important;
+    border-radius: 12px !important;
+    background-color: #0f172a !important;
+    /* Surface level 2 */
+    transition: border-color 0.2s ease-in-out !important;
+}
+
+.upload-zone:hover {
+    border-color: #10b981 !important;
+    /* Emerald on hover */
+}
+
+/* Ingest Console Log */
+.console-wrapper {
+    margin-top: 25px;
+}
+
+.console-wrapper h3 {
+    font-size: 1rem !important;
+    color: #94a3b8 !important;
+    font-weight: 600 !important;
+    margin-bottom: 8px !important;
+}
+
+.status-console textarea {
+    font-family: 'Fira Code', 'Courier New', Courier, monospace !important;
+    background-color: #020617 !important;
+    /* Near Pitch Black */
+    color: #34d399 !important;
+    /* Terminal green */
+    border: 1px solid #1e293b !important;
+    border-radius: 8px !important;
+    padding: 12px !important;
+    font-size: 0.9rem !important;
+    line-height: 1.5 !important;
+}
+
+.selection-status-box {
+    background-color: #1e293b !important;
+    /* Surface Level 1 Dark background */
+    border: 1px solid #334155 !important;
+    /* Medium slate outline */
+    border-radius: 8px !important;
+    padding: 16px 20px !important;
+    width: 100% !important;
+    /* Forces component to span full screen width */
+    margin-bottom: 12px !important;
+    box-sizing: border-box !important;
+}
+
+/* Cleaner, separate horizontal row for action buttons */
+.selection-buttons-row {
+    gap: 10px !important;
+    margin-bottom: 15px !important;
+}
+
+.about-hero {
+    background: linear-gradient(135deg, #1e293b 0%, #0f172a 100%) !important;
+    border: 1px solid #334155 !important;
+    border-radius: 12px !important;
+    padding: 30px !important;
+    margin-bottom: 25px !important;
+}
+
+.about-hero h1 {
+    font-size: 2.2rem !important;
+    font-weight: 800 !important;
+    color: #f8fafc !important;
+    margin-bottom: 6px !important;
+}
+
+.about-hero h3 {
+    font-size: 1.1rem !important;
+    font-weight: 500 !important;
+    color: #94a3b8 !important;
+    margin-top: 0 !important;
+}
+
+/* Technology Badges */
+.tech-badge {
+    display: inline-block;
+    background-color: #064e3b !important;
+    /* Dark forest green background */
+    color: #34d399 !important;
+    /* Light mint text */
+    padding: 4px 12px;
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    font-weight: 700;
+    margin-right: 6px;
+    margin-bottom: 10px;
+    border: 1px solid #047857;
+    letter-spacing: 0.5px;
+}
+
+/* Steps Grid Cards */
+.about-card {
+    background-color: #1e293b !important;
+    border: 1px solid #334155 !important;
+    border-radius: 10px !important;
+    padding: 24px !important;
+    height: 100%;
+    transition: transform 0.2s ease, border-color 0.2s ease !important;
+}
+
+.about-card:hover {
+    transform: translateY(-3px);
+    border-color: #10b981 !important;
+    /* Emerald highlight on hover */
+}
+
+.about-card-icon {
+    font-size: 2rem;
+    margin-bottom: 12px;
+    line-height: 1;
+}
+
+/* Targets Markdown inside cards to avoid global conflicts */
+.about-card h3 {
+    color: #f8fafc !important;
+    font-size: 1.15rem !important;
+    font-weight: 700 !important;
+    margin-top: 0 !important;
+    margin-bottom: 8px !important;
+}
+
+.about-card p {
+    color: #cbd5e1 !important;
+    font-size: 0.9rem !important;
+    line-height: 1.5 !important;
+    margin: 0 !important;
+}
+
+/* Hackathon Announcement Footer */
+.hackathon-footer {
+    margin-top: 35px !important;
+    background-color: #020617 !important;
+    border: 1px solid #1e293b !important;
+    padding: 16px 24px !important;
+    border-radius: 8px !important;
+    align-items: center !important;
+    gap: 15px !important;
+}

ui/about.py

@@ -0,0 +1,64 @@
+import gradio as gr
+
+def render_about():
+    with gr.Column(visible=False, elem_classes="page-container") as page:
+        # Hero Banner with Tech Badges
+        with gr.Column(elem_classes="about-hero"):
+            gr.HTML("""
+            <div style="margin-bottom: 10px;">
+                <span class="tech-badge">MiniCPM-V-4.6</span>
+                <span class="tech-badge">Modal Serverless</span>
+                <span class="tech-badge">Local-First Cache</span>
+                <span class="tech-badge">Vector Retrieval</span>
+            </div>
+            """)
+            gr.Markdown("""
+            # ShutterSearch
+            ### An intelligent, local-first photo archive designed to analyze and search photograph semantics.
+            """)
+        
+        # Corrected: Replaced inline-styled gr.Markdown with styled gr.HTML
+        gr.HTML("""
+        <h2 style="margin-top: 25px; margin-bottom: 15px; font-size: 1.5rem; font-weight: 700; color: #f8fafc;">
+            ⚙️ How it Works
+        </h2>
+        """)
+        
+        # Step Columns
+        with gr.Row():
+            with gr.Column(elem_classes="about-card", scale=1):
+                gr.HTML('<div class="about-card-icon">📥</div>')
+                gr.Markdown("""
+                ### 1. Ingest & Analyze
+                Select your folders. The archive safely processes visual metadata using a serverless Vision Language Model (VLM) running on high-end GPUs.
+                """)
+                
+            with gr.Column(elem_classes="about-card", scale=1):
+                gr.HTML('<div class="about-card-icon">🔍</div>')
+                gr.Markdown("""
+                ### 2. Semantic Search
+                Skip manual tags. Search your directory using natural descriptive phrases (such as *"cinematic lighting on trees"* or *"overcast street portrait"*).
+                """)
+                
+            with gr.Column(elem_classes="about-card", scale=1):
+                gr.HTML('<div class="about-card-icon">📁</div>')
+                gr.Markdown("""
+                ### 3. Bulk Export
+                Organize images within local collections. Select what you need directly from search results to export them in high-fidelity ZIP archives.
+                """)
+        
+        # Footer hackathon card block
+        with gr.Row(elem_classes="hackathon-footer"):
+            gr.HTML("""
+            <div style="display: flex; align-items: center; gap: 15px;">
+                <div style="font-size: 1.8rem; line-height: 1;">🏆</div>
+                <div>
+                    <h4 style="margin: 0 0 3px 0; color: #f8fafc; font-size: 0.95rem; font-weight: 600;">Hugging Face "Build Small" Hackathon</h4>
+                    <p style="margin: 0; color: #94a3b8; font-size: 0.85rem; line-height: 1.4;">
+                        ShutterSearch was designed to fulfill constraints on building lightweight, local-first applications using edge AI concepts.
+                    </p>
+                </div>
+            </div>
+            """)
+            
+    return page

ui/captions.py

@@ -0,0 +1,16 @@
+import gradio as gr
+
+def render_captions():
+    with gr.Column(visible=False) as page:
+        gr.Markdown("# 📝 Caption Browser")
+        with gr.Row():
+            refresh_cap_btn = gr.Button("🔄 Refresh Data", variant="secondary")
+            cap_status = gr.Textbox(interactive=False, show_label=False, scale=4)
+            
+        caption_table = gr.Dataframe(
+            headers=["File", "Summary", "Attire", "Tags"],
+            datatype=["str", "str", "str", "str"],
+            wrap=True, interactive=False,
+            column_widths=["15%", "45%", "20%", "20%"],
+        )
+    return page, refresh_cap_btn, cap_status, caption_table

ui/collections.py

@@ -0,0 +1,88 @@
+# import gradio as gr
+# from caption_store import get_all_collections
+
+# def render_collections():
+#     with gr.Column(visible=False) as page:
+#         gr.Markdown("# 📁 Collections")
+#         with gr.Row():
+#             # Dynamically determine valid initial choices
+#             choices = get_all_collections()
+#             if not choices:
+#                 choices = ["General"]
+#             val = "General" if "General" in choices else choices[0]
+            
+#             view_coll_selector = gr.Dropdown(
+#                 choices=choices, 
+#                 value=val, 
+#                 label="Select Collection to Browse", 
+#                 scale=4
+#             )
+#             refresh_coll_btn = gr.Button("🔄 Refresh", scale=1)
+        
+#         coll_status = gr.Markdown("Browse your organized photos.")
+#         coll_gallery = gr.Gallery(label="Collection Photos", columns=5, height="auto")
+        
+#     return page, view_coll_selector, refresh_coll_btn, coll_status, coll_gallery
+
+
+import os
+import gradio as gr
+from caption_store import get_all_collections
+
+def render_collections():
+    # Gradio selection tracking states
+    selected_paths = gr.State([])
+    loaded_original_paths = gr.State([])
+
+    with gr.Column(visible=False, elem_classes="page-container") as page:
+        gr.HTML("""
+        <div style='margin-bottom: 20px;'>
+            <h1 style='font-size: 2rem; font-weight: 700; color: #f8fafc;'>📁 Browse Collections</h1>
+            <p style='color: #94a3b8;'>Select images by clicking them in the gallery to package and download.</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            choices = get_all_collections()
+            if not choices:
+                choices = ["General"]
+            val = "General" if "General" in choices else choices[0]
+            
+            view_coll_selector = gr.Dropdown(
+                choices=choices, 
+                value=val, 
+                label="Select Collection to Browse", 
+                scale=4
+            )
+            refresh_coll_btn = gr.Button("🔄 Refresh list", scale=1)
+            
+        coll_status = gr.Markdown("Browse your organized photos.")
+
+        # Full-width panel for selected files output
+        selection_status = gr.Markdown(
+            value="**0** image(s) selected for download packaging.\n\n*No files currently selected.*",
+            elem_classes="selection-status-box"
+        )
+
+        # Standalone row for action buttons
+        with gr.Row(elem_classes="selection-buttons-row"):
+            select_all_btn = gr.Button("✅ Select All", size="sm", variant="secondary")
+            clear_selection_btn = gr.Button("🧹 Clear Selection", size="sm", variant="secondary")
+            download_btn = gr.Button("📦 Zip & Download Selected", variant="primary", size="sm")
+
+        # Dynamic hidden archive download trigger
+        download_file = gr.File(label="Source Quality ZIP Archive", visible=False)
+        
+        coll_gallery = gr.Gallery(
+            label="Collection Photos", 
+            columns=5, 
+            height="auto", 
+            elem_classes="custom-gallery",
+            allow_preview=False
+        )
+        
+    return (
+        page, view_coll_selector, refresh_coll_btn, coll_status, coll_gallery, 
+        selected_paths, loaded_original_paths, selection_status, download_btn, 
+        download_file, clear_selection_btn, select_all_btn
+    )

ui/home.py

@@ -0,0 +1,157 @@
+# import gradio as gr
+
+# def render_home():
+#     with gr.Column(visible=True) as page:
+#         with gr.Row():
+#             with gr.Column(scale=2):
+#                 gr.Markdown("""
+#                 # Welcome to ShutterSearch
+#                 ### Your intelligent local-first photo archive.
+                
+#                 ShutterSearch uses state-of-the-art vision models to understand your photography. 
+#                 Keep your photos organized in collections and find them instantly with natural language search.
+                
+#                 - **Semantic Search**: Find "sunset on a beach" even if you didn't tag it.
+#                 - **Automatic Captioning**: Powered by MiniCPM-V-4.6.
+#                 - **Privacy First**: Everything runs on your terms.
+#                 """)
+#                 start_btn = gr.Button("Start Ingesting", variant="primary", size="lg")
+#             with gr.Column(scale=1):
+#                 gr.Image("https://images.unsplash.com/photo-1542038784456-1ea8e935640e?q=80&w=1000&auto=format&fit=crop", 
+#                          label="Photography", show_label=False, interactive=False)
+#     return page, start_btn
+
+
+import gradio as gr
+import os
+
+def render_home():
+    root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    img_path = os.path.join(root_dir, "public", "heroImage.png")
+    
+    print(f"Root directory: {root_dir}")
+    print(f"Image path: {img_path}")
+    print(f"File exists: {os.path.exists(img_path)}")
+    with gr.Column(visible=True) as page:
+        gr.HTML("""
+        <style>
+            .hero-container {
+                display: flex;
+                align-items: center;
+                justify-content: space-between;
+                padding: 60px 40px;
+                min-height: 80vh;
+                gap: 60px;
+            }
+            .hero-content {
+                flex: 1;
+                max-width: 600px;
+            }
+            .hero-title {
+                font-size: 3.5rem;
+                font-weight: 800;
+                background: linear-gradient(135deg, #f8fafc 0%, #94a3b8 100%);
+                -webkit-background-clip: text;
+                -webkit-text-fill-color: transparent;
+                margin-bottom: 20px;
+                line-height: 1.2;
+            }
+            .hero-subtitle {
+                font-size: 1.25rem;
+                color: #64748b;
+                margin-bottom: 30px;
+                line-height: 1.6;
+            }
+            .hero-description {
+                font-size: 1rem;
+                color: #94a3b8;
+                line-height: 1.8;
+                margin-bottom: 40px;
+            }
+            .feature-list {
+                list-style: none;
+                padding: 0;
+                margin: 0 0 40px 0;
+            }
+            .feature-list li {
+                padding: 4px 0;
+                color: #cbd5e1;
+                font-size: 0.95rem;
+                display: flex;
+                align-items: center;
+                gap: 4px;
+            }
+            .feature-list li::before {
+                content: "✓";
+                color: #10b981;
+                font-weight: bold;
+                font-size: 1.2rem;
+            }
+            .hero-image-container {
+                flex: 1;
+                display: flex;
+                justify-content: center;
+                align-items: center;
+            }
+            .hero-image {
+                max-width: 500px;
+                height: auto;
+                filter: drop-shadow(0 20px 40px rgba(0, 0, 0, 0.4));
+            }
+            .cta-button {
+                background: linear-gradient(135deg, #10b981 0%, #059669 100%) !important;
+                color: white !important;
+                border: none !important;
+                padding: 16px 40px !important;
+                font-size: 1.1rem !important;
+                font-weight: 600 !important;
+                border-radius: 12px !important;
+                cursor: pointer !important;
+                transition: all 0.3s ease !important;
+                box-shadow: 0 4px 15px rgba(16, 185, 129, 0.3) !important;
+            }
+            .cta-button:hover {
+                transform: translateY(-2px) !important;
+                box-shadow: 0 8px 25px rgba(16, 185, 129, 0.4) !important;
+            }
+        </style>
+        
+        <div class="hero-container">
+            <div class="hero-content">
+                <h1 class="hero-title">Preserve Your Precious Moments</h1>
+                <p class="hero-subtitle">Your intelligent, privacy-first photo archive</p>
+                
+                <ul class="feature-list">
+                    <li>AI-powered semantic search - find photos naturally</li>
+                    <li>Automatic captioning with MiniCPM-V-4.6</li>
+                </ul>
+                
+                <button class="cta-button" id="start-ingest-btn">Get Started</button>
+            </div>
+            
+            <div class="hero-image-container">
+                <img src="https://i.postimg.cc/zBKzF24k/hero-Image.png" alt="Precious Moments" class="hero-image">
+            </div>
+        </div>
+        """)
+        
+        # Hidden button for Gradio event handling
+        start_btn = gr.Button("Start Ingesting", variant="primary", size="lg", visible=False)
+        
+        # JavaScript to trigger the hidden button when CTA is clicked
+        gr.HTML("""
+        <script>
+            document.addEventListener('DOMContentLoaded', function() {
+                const ctaBtn = document.getElementById('start-ingest-btn');
+                const gradioBtn = document.querySelector('button[data-testid="Start Ingesting"]');
+                
+                if (ctaBtn && gradioBtn) {
+                    ctaBtn.addEventListener('click', function() {
+                        gradioBtn.click();
+                    });
+                }
+            });
+        </script>
+        """)
+    
+    return page, start_btn

ui/ingest.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from caption_store import get_all_collections
+
+def render_ingest():
+    with gr.Column(visible=False, elem_classes="page-container") as page:
+        gr.HTML("""
+        <div style='margin-bottom: 20px;'>
+            <h1 style='font-size: 2rem; font-weight: 700; color: #f8fafc;'>📥 Ingest Photos</h1>
+            <p style='color: #94a3b8;'>Upload images to your archive and generate AI descriptions.</p>
+        </div>
+        """)
+        
+        with gr.Row(equal_height=True):
+            # Left: File Uploader
+            with gr.Column(scale=3):
+                upload = gr.File(
+                    label="Drag & Drop Images Here",
+                    file_count="multiple",
+                    file_types=[".jpg", ".jpeg", ".png", ".webp", ".tiff"],
+                    height=280,
+                    elem_classes="upload-zone"
+                )
+            
+            # Right: Destination & Collection Controls
+            with gr.Column(scale=2, elem_classes="settings-card"):
+                gr.Markdown("### ⚙️ Collection Destination")
+                
+                use_new_coll = gr.Checkbox(
+                    label="Create a brand new collection", 
+                    value=False,
+                    elem_classes="custom-checkbox"
+                )
+                
+                # Safely parse collection values on first load
+                choices = get_all_collections()
+                if not choices:
+                    choices = ["General"]
+                default_val = "General" if "General" in choices else choices[0]
+                
+                coll_dropdown = gr.Dropdown(
+                    choices=choices, 
+                    label="Target Collection", 
+                    value=default_val,
+                    interactive=True,
+                    visible=True
+                )
+                
+                new_coll_name = gr.Textbox(
+                    label="New Collection Name", 
+                    placeholder="e.g. Summer Vacation 2024",
+                    visible=False
+                )
+                
+                ingest_btn = gr.Button(
+                    "🚀 Start Processing", 
+                    variant="primary", 
+                    size="lg"
+                )
+        
+        # Bottom: Terminal-style status log
+        with gr.Column(elem_classes="console-wrapper"):
+            gr.Markdown("### 🖥️ Ingestion Logs")
+            ingest_status = gr.Textbox(
+                value="System ready. Awaiting file upload...",
+                show_label=False,
+                interactive=False, 
+                lines=6,
+                elem_classes="status-console"
+            )
+            
+    return page, upload, coll_dropdown, use_new_coll, new_coll_name, ingest_btn, ingest_status

ui/search.py

@@ -0,0 +1,74 @@
+# import gradio as gr
+# from caption_store import get_all_collections
+
+# def render_search():
+#     with gr.Column(visible=False) as page:
+#         gr.Markdown("# 🔍 AI Search")
+#         with gr.Row():
+#             search_query = gr.Textbox(
+#                 placeholder="Describe what you're looking for... (e.g. 'moody forest portrait')",
+#                 label="Search Query", scale=4
+#             )
+#             search_col_filter = gr.Dropdown(
+#                 choices=["All"] + get_all_collections(), value="All", label="Filter by Collection", scale=1
+#             )
+#             search_btn = gr.Button("Search", variant="primary", scale=1)
+        
+#         search_status_msg = gr.Markdown("Enter a query to start searching.")
+#         search_gallery = gr.Gallery(label="Search Results", columns=4, height="auto")
+#     return page, search_query, search_col_filter, search_btn, search_status_msg, search_gallery
+import gradio as gr
+from caption_store import get_all_collections
+
+def render_search():
+    # Selection and path tracking states for search
+    selected_paths = gr.State([])
+    loaded_original_paths = gr.State([])
+
+    with gr.Column(visible=False, elem_classes="page-container") as page:
+        gr.HTML("""
+        <div style='margin-bottom: 20px;'>
+            <h1 style='font-size: 2rem; font-weight: 700; color: #f8fafc;'>🔍 AI Search</h1>
+            <p style='color: #94a3b8;'>Search your archive using natural language, select results, and bulk download.</p>
+        </div>
+        """)
+        with gr.Row():
+            search_query = gr.Textbox(
+                placeholder="Describe what you're looking for... (e.g. 'moody forest portrait')",
+                label="Search Query", scale=4
+            )
+            search_col_filter = gr.Dropdown(
+                choices=["All"] + get_all_collections(), value="All", label="Filter by Collection", scale=1
+            )
+            search_btn = gr.Button("Search", variant="primary", scale=1)
+        
+        search_status_msg = gr.Markdown("Enter a query to start searching.")
+
+        # Full-width panel for selected files output
+        selection_status = gr.Markdown(
+            value="**0** image(s) selected for download packaging.\n\n*No files currently selected.*",
+            elem_classes="selection-status-box"
+        )
+
+        # Standalone row for action buttons
+        with gr.Row(elem_classes="selection-buttons-row"):
+            select_all_btn = gr.Button("✅ Select All Results", size="sm", variant="secondary")
+            clear_selection_btn = gr.Button("🧹 Clear Selection", size="sm", variant="secondary")
+            download_btn = gr.Button("📦 Zip & Download Selected", variant="primary", size="sm")
+
+        # Hidden file output for compilation download
+        download_file = gr.File(label="Source Quality ZIP Archive", visible=False)
+        
+        search_gallery = gr.Gallery(
+            label="Search Results", 
+            columns=4, 
+            height="auto", 
+            elem_classes="custom-gallery",
+            allow_preview=False
+        )
+        
+    return (
+        page, search_query, search_col_filter, search_btn, search_status_msg, search_gallery,
+        selected_paths, loaded_original_paths, selection_status, download_btn,
+        download_file, clear_selection_btn, select_all_btn
+    )

ui/sidebar.py

@@ -0,0 +1,27 @@
+import gradio as gr
+from caption_store import entry_count
+
+def render_sidebar():
+    with gr.Sidebar(elem_id="custom-sidebar"):
+        # Custom HTML Header
+        gr.HTML("""
+        <div class="brand-header">
+            <h1>ShutterSearch</h1>
+            <p>Modern Photo Archive</p>
+        </div>
+        """)
+        
+        # Added non-breaking spaces (&nbsp;) after emojis for visual breathing room
+        btns = {
+            "home": gr.Button("🏠Home", elem_classes="nav-btn"),
+            "ingest": gr.Button("📥Ingest", elem_classes="nav-btn"),
+            "search": gr.Button("🔍Search", elem_classes="nav-btn"),
+            "collections": gr.Button("📁Collections", elem_classes="nav-btn"),
+            "captions": gr.Button("📝Captions", elem_classes="nav-btn"),
+            "about": gr.Button("ℹ️About", elem_classes="nav-btn"),
+        }
+        
+        with gr.Column(elem_classes="stats-container"):
+            stats = gr.Label(value=f"Total Photos: {entry_count()}", label="Archive Stats")
+            
+    return btns, stats