Enhance search functionality and UI components

- Updated example queries for better clarity and relevance
- Added a "Copy link" button for search results and galaxy details
- Implemented URL state management for shareable search links

src/callbacks.py

@@ -4,9 +4,10 @@ import json
 import time
 import logging
 import traceback
+import uuid
 import pandas as pd
 import dash
-from dash import Input, Output, State, callback_context, html
+from dash import Input, Output, State, callback_context, html, dcc
 import dash_bootstrap_components as dbc
 
 import src.config as config
@@ -184,12 +185,12 @@ def register_callbacks(app, search_service: SearchService):
         button_id = ctx.triggered[0]["prop_id"].split(".")[0]
 
         example_queries = {
-            "example-1": "Merging edge-on galaxy",
+            "example-1": "Two edge-on galaxies",
             "example-2": "A peculiar interacting galaxy system featuring plenty of tidal tails and a disturbed morphology",
             "example-3": "galaxy with stream",
             "example-5": "A violent merger in progress with visible tidal features",
             "example-6": "Low surface brightness",
-            "example-7": "face-on ring galaxy",
+            "example-7": "A face-on spiral with ring-like circular structure around a core",
             "example-8": "a bursty, star forming galaxy"
         }
 
@@ -205,7 +206,8 @@ def register_callbacks(app, search_service: SearchService):
          Output("search-results", "children"),
          Output("search-data", "data"),
          Output("download-button", "disabled"),
-         Output("download-button-advanced", "disabled")],
+         Output("download-button-advanced", "disabled"),
+         Output("current-search-params", "data")],
         [Input("search-button", "n_clicks"),
          Input("search-input", "n_submit"),
          Input("search-button-advanced", "n_clicks")],
@@ -246,7 +248,10 @@ def register_callbacks(app, search_service: SearchService):
         # Otherwise perform basic search
         query = query_basic
         if not query or not query.strip():
-            return "", dbc.Alert("Please enter a search query", color="warning"), None, True, True
+            return "", dbc.Alert("Please enter a search query", color="warning"), None, True, True, None
+
+        # Generate unique request_id for this search
+        request_id = uuid.uuid4().hex
 
         try:
             # Extract min and max from slider range
@@ -264,13 +269,13 @@ def register_callbacks(app, search_service: SearchService):
                 rmag_min=rmag_min,
                 rmag_max=rmag_max
             )
-            log_query_to_csv(query_xml)
+            log_query_to_csv(query_xml, request_id=request_id)
 
             # Build results grid - only load first 60 images
             grid_items = build_galaxy_grid(df.head(DEFAULT_DISPLAY_COUNT))
 
             # Prepare data for store
-            search_data = prepare_search_data(df, query)
+            search_data = prepare_search_data(df, query, request_id=request_id)
 
             # Create load more button
             load_more_button = create_load_more_button(len(df), DEFAULT_DISPLAY_COUNT) if len(df) > DEFAULT_DISPLAY_COUNT else None
@@ -282,8 +287,19 @@ def register_callbacks(app, search_service: SearchService):
 
             # Build complete results container
             results_container = html.Div([
-                html.P(f"Top {len(df)} matching galaxies (showing {min(DEFAULT_DISPLAY_COUNT, len(df))})",
-                       className="results-header mb-2 text-center"),
+                html.Div([
+                    html.P(f"Top {len(df)} matching galaxies (showing {min(DEFAULT_DISPLAY_COUNT, len(df))})",
+                           className="results-header mb-2 text-center d-inline-block me-2"),
+                    dbc.Button(
+                        [html.I(className="fas fa-link me-1"), "Copy link"],
+                        id="copy-results-link",
+                        color="link",
+                        size="sm",
+                        n_clicks=0,
+                        className="info-button"
+                    ),
+                    html.Span(id="copy-results-feedback", style={"marginLeft": "8px", "color": "#28a745", "fontSize": "0.8rem"})
+                ], className="text-center"),
                 html.P(f"'{query}'{filter_desc}",
                        className="text-center mb-3",
                        style={"color": "rgba(245, 245, 247, 0.6)", "font-size": "0.9rem"}),
@@ -291,20 +307,51 @@ def register_callbacks(app, search_service: SearchService):
                 load_more_button
             ])
 
-            return "", results_container, search_data, False, False
+            # Store search params for URL generation
+            search_params = {
+                "text_queries": [query],
+                "text_weights": [1.0],
+                "image_queries": [],
+                "image_weights": [],
+                "rmag_min": rmag_min,
+                "rmag_max": rmag_max
+            }
+
+            return "", results_container, search_data, False, False, search_params
 
         except Exception as e:
             error_msg = dbc.Alert(f"Search failed: {str(e)}", color="danger")
             logger.error(f"Search error: {e}")
             logger.error(f"Full traceback:\n{traceback.format_exc()}")
-            return "", error_msg, None, True, True
+
+            # Log error
+            from src.utils import build_query_xml, log_query_to_csv
+            try:
+                query_xml = build_query_xml(
+                    text_queries=[query],
+                    text_weights=[1.0],
+                    rmag_min=rmag_range[0] if rmag_range else None,
+                    rmag_max=rmag_range[1] if rmag_range else None
+                )
+                log_query_to_csv(
+                    query_xml,
+                    request_id=request_id,
+                    error_occurred=True,
+                    error_message=str(e),
+                    error_type=type(e).__name__
+                )
+            except:
+                pass
+
+            return "", error_msg, None, True, True, None
 
     @app.callback(
         [Output("galaxy-modal", "is_open"),
          Output("modal-title", "children"),
          Output("modal-image", "children"),
          Output("modal-description", "children"),
-         Output("current-galaxy-data", "data")],
+         Output("current-galaxy-data", "data"),
+         Output("copy-galaxy-feedback", "children", allow_duplicate=True)],
         [Input({"type": "galaxy-image", "index": dash.dependencies.ALL}, "n_clicks"),
          Input("close-modal", "n_clicks")],
         [State("galaxy-modal", "is_open"),
@@ -316,17 +363,17 @@ def register_callbacks(app, search_service: SearchService):
         ctx = callback_context
 
         if not ctx.triggered:
-            return False, "", "", "", None
+            return False, "", "", "", None, ""
 
         if ctx.triggered[0]["prop_id"] == "close-modal.n_clicks":
-            return False, "", "", "", None
+            return False, "", "", "", None, ""
 
         if search_data:
             triggered_prop = ctx.triggered[0]["prop_id"]
             triggered_value = ctx.triggered[0]["value"]
 
             if triggered_value is None or triggered_value == 0:
-                return False, "", "", "", None
+                return False, "", "", "", None, ""
 
             if "galaxy-image" in triggered_prop:
                 try:
@@ -345,17 +392,101 @@ def register_callbacks(app, search_service: SearchService):
                             "r_mag": galaxy_info["r_mag"]
                         }
 
+                        # Log click event
+                        from src.utils import log_click_event
+                        request_id = search_data.get("request_id")
+                        log_click_event(
+                            request_id=request_id,
+                            rank=clicked_idx,  # 0-indexed rank
+                            primary_key=galaxy_info[ZILLIZ_PRIMARY_KEY],
+                            ra=galaxy_info["ra"],
+                            dec=galaxy_info["dec"],
+                            r_mag=galaxy_info["r_mag"],
+                            distance=galaxy_info["distance"]
+                        )
+
                         return (
                             True,
                             f"Galaxy at RA={galaxy_info['ra']:.6f}, Dec={galaxy_info['dec']:.6f}",
                             image_element,
                             description_element,
-                            galaxy_data
+                            galaxy_data,
+                            ""  # Clear copy feedback when opening new galaxy
                         )
                 except:
                     pass
 
-        return False, "", "", "", None
+        return False, "", "", "", None, ""
+
+    @app.callback(
+        [Output("galaxy-modal", "is_open", allow_duplicate=True),
+         Output("modal-title", "children", allow_duplicate=True),
+         Output("modal-image", "children", allow_duplicate=True),
+         Output("modal-description", "children", allow_duplicate=True),
+         Output("current-galaxy-data", "data", allow_duplicate=True),
+         Output("pending-expand-galaxy", "data", allow_duplicate=True),
+         Output("copy-galaxy-feedback", "children", allow_duplicate=True)],
+        [Input("search-data", "data")],
+        [State("pending-expand-galaxy", "data")],
+        prevent_initial_call=True
+    )
+    def expand_galaxy_from_url(search_data, pending_galaxy_id):
+        """Expand galaxy modal if there's a pending galaxy from URL state."""
+        if not pending_galaxy_id or not search_data:
+            return dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update
+
+        # Find the galaxy by ID in search results
+        primary_keys = search_data.get(ZILLIZ_PRIMARY_KEY, [])
+
+        # Handle potential bytes encoding issue - try to match with and without b'' wrapper
+        target_id = pending_galaxy_id
+        # Clean up the ID if it has bytes notation
+        if isinstance(target_id, str) and target_id.startswith("b'") and target_id.endswith("'"):
+            target_id = target_id[2:-1]
+
+        try:
+            # Try to find exact match first
+            if target_id in primary_keys:
+                idx = primary_keys.index(target_id)
+            else:
+                # Try cleaning primary keys too
+                cleaned_keys = []
+                for pk in primary_keys:
+                    if isinstance(pk, str) and pk.startswith("b'") and pk.endswith("'"):
+                        cleaned_keys.append(pk[2:-1])
+                    else:
+                        cleaned_keys.append(pk)
+
+                if target_id in cleaned_keys:
+                    idx = cleaned_keys.index(target_id)
+                else:
+                    # Galaxy not found in results
+                    return dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, None, dash.no_update
+
+            # Extract galaxy info and build modal content
+            galaxy_info = extract_galaxy_info(search_data, idx)
+            image_element, description_element = build_modal_content(galaxy_info)
+
+            galaxy_data = {
+                ZILLIZ_PRIMARY_KEY: galaxy_info[ZILLIZ_PRIMARY_KEY],
+                "ra": galaxy_info["ra"],
+                "dec": galaxy_info["dec"],
+                "distance": galaxy_info["distance"],
+                "r_mag": galaxy_info["r_mag"]
+            }
+
+            return (
+                True,  # Open modal
+                f"Galaxy at RA={galaxy_info['ra']:.6f}, Dec={galaxy_info['dec']:.6f}",
+                image_element,
+                description_element,
+                galaxy_data,
+                None,  # Clear pending galaxy
+                ""  # Clear copy feedback when opening galaxy from URL
+            )
+        except (ValueError, IndexError):
+            # Galaxy not found, clear the pending state
+            return dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, None, dash.no_update
 
     @app.callback(
         Output("info-modal", "is_open"),
@@ -401,8 +532,19 @@ def register_callbacks(app, search_service: SearchService):
             load_more_button = create_load_more_button(total_count, next_count) if next_count < total_count else None
 
             results_container = html.Div([
-                html.P(f"Top {total_count} matching galaxies (showing {next_count})",
-                       className="results-header mb-2 text-center"),
+                html.Div([
+                    html.P(f"Top {total_count} matching galaxies (showing {next_count})",
+                           className="results-header mb-2 text-center d-inline-block me-2"),
+                    dbc.Button(
+                        [html.I(className="fas fa-link me-1"), "Copy link"],
+                        id="copy-results-link",
+                        color="link",
+                        size="sm",
+                        n_clicks=0,
+                        className="info-button"
+                    ),
+                    html.Span(id="copy-results-feedback", style={"marginLeft": "8px", "color": "#28a745", "fontSize": "0.8rem"})
+                ], className="text-center"),
                 html.P(f"'{search_data['query']}'",
                        className="text-center mb-3",
                        style={"color": "rgba(245, 245, 247, 0.6)", "font-size": "0.9rem"}),
@@ -492,6 +634,9 @@ def register_callbacks(app, search_service: SearchService):
                                      additional_ra_values, additional_dec_values,
                                      additional_operations):
         """Perform advanced search combining main query with additional queries."""
+        # Generate unique request_id for this search
+        request_id = uuid.uuid4().hex
+
         def operation_to_weight(op_str):
             """Convert operation string to float weight."""
             if op_str == "+":
@@ -557,7 +702,7 @@ def register_callbacks(app, search_service: SearchService):
 
         # Validate that we have at least one query
         if not text_queries and not image_queries:
-            return "", dbc.Alert("Please enter at least one text or image query", color="warning"), None, True, True
+            return "", dbc.Alert("Please enter at least one text or image query", color="warning"), None, True, True, None
 
         try:
             # Extract min and max from slider range
@@ -585,7 +730,7 @@ def register_callbacks(app, search_service: SearchService):
                 rmag_min=rmag_min,
                 rmag_max=rmag_max
             )
-            log_query_to_csv(query_xml)
+            log_query_to_csv(query_xml, request_id=request_id)
 
             # Build results grid
             grid_items = build_galaxy_grid(df.head(DEFAULT_DISPLAY_COUNT))
@@ -637,7 +782,7 @@ def register_callbacks(app, search_service: SearchService):
                 filter_desc = f" + r-mag: [{rmag_min:.1f}, {rmag_max:.1f}]"
 
             # Prepare data for store
-            search_data = prepare_search_data(df, query_description, is_vector_search=True)
+            search_data = prepare_search_data(df, query_description, is_vector_search=True, request_id=request_id)
             search_data["text_queries"] = text_queries
             search_data["text_weights"] = text_weights
             search_data["image_queries"] = image_queries
@@ -648,8 +793,19 @@ def register_callbacks(app, search_service: SearchService):
 
             # Build results container
             results_container = html.Div([
-                html.P(f"Top {len(df)} matching galaxies (showing {min(DEFAULT_DISPLAY_COUNT, len(df))})",
-                       className="results-header mb-2 text-center"),
+                html.Div([
+                    html.P(f"Top {len(df)} matching galaxies (showing {min(DEFAULT_DISPLAY_COUNT, len(df))})",
+                           className="results-header mb-2 text-center d-inline-block me-2"),
+                    dbc.Button(
+                        [html.I(className="fas fa-link me-1"), "Copy link"],
+                        id="copy-results-link",
+                        color="link",
+                        size="sm",
+                        n_clicks=0,
+                        className="info-button"
+                    ),
+                    html.Span(id="copy-results-feedback", style={"marginLeft": "8px", "color": "#28a745", "fontSize": "0.8rem"})
+                ], className="text-center"),
                 html.P(
                     query_display_parts + ([f"{filter_desc}"] if filter_desc else []),
                     className="text-center mb-3",
@@ -659,17 +815,378 @@ def register_callbacks(app, search_service: SearchService):
                 load_more_button
             ])
 
-            return "", results_container, search_data, False, False
+            # Store search params for URL generation (convert image_queries dict to tuple format)
+            search_params = {
+                "text_queries": text_queries,
+                "text_weights": text_weights,
+                "image_queries": [(img['ra'], img['dec'], img.get('fov', 0.025)) for img in image_queries],
+                "image_weights": image_weights,
+                "rmag_min": rmag_min,
+                "rmag_max": rmag_max
+            }
+
+            return "", results_container, search_data, False, False, search_params
 
         except Exception as e:
             error_msg = dbc.Alert(f"Advanced search failed: {str(e)}", color="danger")
             logger.error(f"Advanced search error: {e}")
             logger.error(f"Full traceback:\n{traceback.format_exc()}")
-            return "", error_msg, None, True, True
+
+            # Log error
+            from src.utils import build_query_xml, log_query_to_csv
+            try:
+                query_xml = build_query_xml(
+                    text_queries=text_queries if text_queries else None,
+                    text_weights=text_weights if text_weights else None,
+                    image_queries=image_queries if image_queries else None,
+                    image_weights=image_weights if image_weights else None,
+                    rmag_min=rmag_range[0] if rmag_range else None,
+                    rmag_max=rmag_range[1] if rmag_range else None
+                )
+                log_query_to_csv(
+                    query_xml,
+                    request_id=request_id,
+                    error_occurred=True,
+                    error_message=str(e),
+                    error_type=type(e).__name__
+                )
+            except:
+                pass
+
+            return "", error_msg, None, True, True, None
+
+    # ===== URL State Management Callbacks =====
+
+    @app.callback(
+        [Output("search-input-advanced", "value", allow_duplicate=True),
+         Output("main-vector-operation", "value", allow_duplicate=True),
+         Output("main-query-type", "value", allow_duplicate=True),
+         Output("main-vector-ra", "value", allow_duplicate=True),
+         Output("main-vector-dec", "value", allow_duplicate=True),
+         Output("vector-inputs", "children", allow_duplicate=True),
+         Output("rmag-slider", "value", allow_duplicate=True),
+         Output("advanced-search-interface", "style", allow_duplicate=True),
+         Output("basic-search-bar", "style", allow_duplicate=True),
+         Output("vector-arrow", "className", allow_duplicate=True),
+         Output("url-search-trigger", "data", allow_duplicate=True),
+         Output("pending-expand-galaxy", "data")],
+        Input("url", "search"),
+        prevent_initial_call=True
+    )
+    def restore_state_from_url(search_string):
+        """Parse URL and populate UI, then trigger search if state is present."""
+        from src.url_state import parse_url_search_param
+
+        # Parse URL state
+        state = parse_url_search_param(search_string)
+
+        # If no state, return defaults (don't trigger search)
+        if not state.get('text_queries') and not state.get('image_queries'):
+            return (
+                dash.no_update,  # search-input-advanced
+                dash.no_update,  # main-vector-operation
+                dash.no_update,  # main-query-type
+                dash.no_update,  # main-vector-ra
+                dash.no_update,  # main-vector-dec
+                dash.no_update,  # vector-inputs
+                dash.no_update,  # rmag-slider
+                dash.no_update,  # advanced-search-interface style
+                dash.no_update,  # basic-search-bar style
+                dash.no_update,  # vector-arrow
+                dash.no_update,  # url-search-trigger
+                None  # pending-expand-galaxy
+            )
+
+        # Always restore to advanced mode
+        text_queries = state.get('text_queries', [])
+        text_weights = state.get('text_weights', [])
+        image_queries = state.get('image_queries', [])
+        image_weights = state.get('image_weights', [])
+        rmag_min = state.get('rmag_min', 13.0)
+        rmag_max = state.get('rmag_max', 20.0)
+        expand_galaxy = state.get('expand_galaxy')
+
+        # Determine main query (first query - text or image)
+        main_text = ""
+        main_operation = "+"
+        main_query_type = "text"
+        main_ra = None
+        main_dec = None
+        vector_children = []
+
+        all_queries = []
+        # Combine text and image queries with their types
+        for i, (query, weight) in enumerate(zip(text_queries, text_weights)):
+            all_queries.append(('text', query, None, None, weight))
+        for i, (img_query, weight) in enumerate(zip(image_queries, image_weights)):
+            all_queries.append(('image', None, img_query[0], img_query[1], weight))
+
+        if all_queries:
+            # First query becomes main query
+            first_type, first_text, first_ra, first_dec, first_weight = all_queries[0]
+            main_query_type = first_type
+            main_operation = weight_to_operation_str(first_weight)
+
+            if first_type == 'text':
+                main_text = first_text
+            else:
+                main_ra = first_ra
+                main_dec = first_dec
+
+            # Remaining queries become additional vectors
+            for idx, (qtype, qtext, qra, qdec, qweight) in enumerate(all_queries[1:]):
+                from src.components import create_vector_input_row
+                operation_str = weight_to_operation_str(qweight)
+                if qtype == 'text':
+                    row = create_vector_input_row(
+                        idx,
+                        query_type='text',
+                        text_value=qtext,
+                        operation=operation_str
+                    )
+                    vector_children.append(row)
+                else:
+                    row = create_vector_input_row(
+                        idx,
+                        query_type='image',
+                        ra=qra,
+                        dec=qdec,
+                        operation=operation_str
+                    )
+                    vector_children.append(row)
+
+        return (
+            main_text,  # search-input-advanced
+            main_operation,  # main-vector-operation
+            main_query_type,  # main-query-type
+            main_ra,  # main-vector-ra
+            main_dec,  # main-vector-dec
+            vector_children,  # vector-inputs
+            [rmag_min, rmag_max],  # rmag-slider
+            {"display": "block"},  # advanced-search-interface (show)
+            {"display": "none"},  # basic-search-bar (hide)
+            "fas fa-chevron-up me-2",  # vector-arrow (up arrow for advanced mode)
+            1,  # url-search-trigger (trigger search)
+            expand_galaxy  # pending-expand-galaxy
+        )
+
+    @app.callback(
+        Output("search-button-advanced", "n_clicks", allow_duplicate=True),
+        Input("url-search-trigger", "data"),
+        State("search-button-advanced", "n_clicks"),
+        prevent_initial_call=True
+    )
+    def trigger_search_from_url(trigger, current_clicks):
+        """Click search button after URL state is restored."""
+        if trigger:
+            return (current_clicks or 0) + 1
+        return dash.no_update
+
+    @app.callback(
+        Output("url", "search", allow_duplicate=True),
+        Input("current-search-params", "data"),
+        State("url", "search"),
+        prevent_initial_call=True
+    )
+    def update_url_after_search(search_params, current_url):
+        """Update browser URL without reload after search completes."""
+        from src.url_state import encode_search_state
+        from src.config import URL_STATE_PARAM
+
+        if not search_params:
+            return dash.no_update
+
+        # Extract params
+        text_queries = search_params.get('text_queries', [])
+        text_weights = search_params.get('text_weights', [])
+        image_queries = search_params.get('image_queries', [])
+        image_weights = search_params.get('image_weights', [])
+        rmag_min = search_params.get('rmag_min', 13.0)
+        rmag_max = search_params.get('rmag_max', 20.0)
+
+        # Encode state
+        encoded = encode_search_state(
+            text_queries=text_queries,
+            text_weights=text_weights,
+            image_queries=image_queries,
+            image_weights=image_weights,
+            rmag_min=rmag_min,
+            rmag_max=rmag_max
+        )
+
+        # Build new URL search string
+        new_url = f"?{URL_STATE_PARAM}={encoded}"
+
+        # Only update if different from current
+        if new_url == current_url:
+            raise dash.exceptions.PreventUpdate
+
+        return new_url
+
+    # Clientside callback for copying results link to clipboard
+    app.clientside_callback(
+        """
+        function(n_clicks, search_params) {
+            if (!n_clicks || !search_params) {
+                return "";
+            }
+
+            // Build the URL from search params
+            var state = {};
+            if (search_params.text_queries && search_params.text_queries.length > 0) {
+                state.tq = search_params.text_queries;
+                state.tw = search_params.text_weights;
+            }
+            if (search_params.image_queries && search_params.image_queries.length > 0) {
+                state.iq = search_params.image_queries;
+                state.iw = search_params.image_weights;
+            }
+            if (search_params.rmag_min !== 13.0) {
+                state.rmin = search_params.rmag_min;
+            }
+            if (search_params.rmag_max !== 20.0) {
+                state.rmax = search_params.rmag_max;
+            }
+
+            var jsonStr = JSON.stringify(state);
+            var encoded = btoa(jsonStr).replace(/=/g, '');
+            var url = window.location.origin + "?s=" + encoded;
+
+            // Copy to clipboard using fallback method
+            var textArea = document.createElement("textarea");
+            textArea.value = url;
+            textArea.style.position = "fixed";
+            textArea.style.left = "-999999px";
+            textArea.style.top = "-999999px";
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+
+            try {
+                document.execCommand('copy');
+                document.body.removeChild(textArea);
+                // Clear feedback after 2 seconds
+                setTimeout(function() {
+                    var el = document.getElementById('copy-results-feedback');
+                    if (el) el.textContent = '';
+                }, 2000);
+                return "Copied!";
+            } catch (err) {
+                document.body.removeChild(textArea);
+                // Try modern API as fallback
+                if (navigator.clipboard) {
+                    navigator.clipboard.writeText(url);
+                    setTimeout(function() {
+                        var el = document.getElementById('copy-results-feedback');
+                        if (el) el.textContent = '';
+                    }, 2000);
+                    return "Copied!";
+                }
+                return "Failed to copy";
+            }
+        }
+        """,
+        Output("copy-results-feedback", "children"),
+        Input("copy-results-link", "n_clicks"),
+        State("current-search-params", "data"),
+        prevent_initial_call=True
+    )
+
+    # Clientside callback for copying galaxy link to clipboard
+    app.clientside_callback(
+        """
+        function(n_clicks, search_params, galaxy_data) {
+            if (!n_clicks || !search_params || !galaxy_data) {
+                return "";
+            }
+
+            // Build the URL from search params with galaxy expansion
+            var state = {};
+            if (search_params.text_queries && search_params.text_queries.length > 0) {
+                state.tq = search_params.text_queries;
+                state.tw = search_params.text_weights;
+            }
+            if (search_params.image_queries && search_params.image_queries.length > 0) {
+                state.iq = search_params.image_queries;
+                state.iw = search_params.image_weights;
+            }
+            if (search_params.rmag_min !== 13.0) {
+                state.rmin = search_params.rmag_min;
+            }
+            if (search_params.rmag_max !== 20.0) {
+                state.rmax = search_params.rmag_max;
+            }
+            // Add galaxy expansion
+            if (galaxy_data.object_id) {
+                var galaxyId = galaxy_data.object_id;
+                // Clean up bytes notation if present (e.g., "b'1500m885-7090'" -> "1500m885-7090")
+                if (typeof galaxyId === 'string' && galaxyId.startsWith("b'") && galaxyId.endsWith("'")) {
+                    galaxyId = galaxyId.slice(2, -1);
+                }
+                state.exp = galaxyId;
+            }
+
+            var jsonStr = JSON.stringify(state);
+            var encoded = btoa(jsonStr).replace(/=/g, '');
+            var url = window.location.origin + "?s=" + encoded;
+
+            // Copy to clipboard using fallback method
+            var textArea = document.createElement("textarea");
+            textArea.value = url;
+            textArea.style.position = "fixed";
+            textArea.style.left = "-999999px";
+            textArea.style.top = "-999999px";
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+
+            try {
+                document.execCommand('copy');
+                document.body.removeChild(textArea);
+                // Clear feedback after 2 seconds
+                setTimeout(function() {
+                    var el = document.getElementById('copy-galaxy-feedback');
+                    if (el) el.textContent = '';
+                }, 2000);
+                return "Copied!";
+            } catch (err) {
+                document.body.removeChild(textArea);
+                // Try modern API as fallback
+                if (navigator.clipboard) {
+                    navigator.clipboard.writeText(url);
+                    setTimeout(function() {
+                        var el = document.getElementById('copy-galaxy-feedback');
+                        if (el) el.textContent = '';
+                    }, 2000);
+                    return "Copied!";
+                }
+                return "Failed to copy";
+            }
+        }
+        """,
+        Output("copy-galaxy-feedback", "children"),
+        Input("copy-galaxy-link", "n_clicks"),
+        [State("current-search-params", "data"),
+         State("current-galaxy-data", "data")],
+        prevent_initial_call=True
+    )
 
 
 # Helper functions for callbacks
 
+def weight_to_operation_str(weight):
+    """Convert weight float to operation string for UI."""
+    if weight == 1.0:
+        return "+"
+    elif weight == -1.0:
+        return "-"
+    elif weight > 0:
+        return f"+{int(weight)}"
+    else:
+        return str(int(weight))
+
+
+
 def build_galaxy_grid(df: pd.DataFrame) -> list:
     """Build galaxy grid items from DataFrame.
 
@@ -731,18 +1248,19 @@ def build_galaxy_card(galaxy_info: dict, index: int):
     ], width=6, md=4, lg=2, className="mb-2 px-1")
 
 
-def prepare_search_data(df: pd.DataFrame, query: str, is_vector_search: bool = False) -> dict:
+def prepare_search_data(df: pd.DataFrame, query: str, is_vector_search: bool = False, request_id: str = None) -> dict:
     """Prepare search data for storage.
 
     Args:
         df: DataFrame with search results
         query: Search query string
         is_vector_search: Whether this is a vector search
+        request_id: Unique ID for this request
 
     Returns:
         Dictionary with search data
     """
-    return {
+    data = {
         ZILLIZ_PRIMARY_KEY: df[ZILLIZ_PRIMARY_KEY].tolist(),
         "ra": df['ra'].tolist(),
         "dec": df['dec'].tolist(),
@@ -753,6 +1271,9 @@ def prepare_search_data(df: pd.DataFrame, query: str, is_vector_search: bool = F
         "query": query,
         "is_vector_search": is_vector_search
     }
+    if request_id:
+        data["request_id"] = request_id
+    return data
 
 
 def extract_galaxy_info(search_data: dict, index: int) -> dict:

src/components.py

@@ -542,8 +542,8 @@ def create_search_container():
                           style={"color": "rgba(245, 245, 247, 0.5)", "font-weight": "300",
                                 "font-size": "0.75rem", "letter-spacing": "0.02em"}),
                     html.Div([
-                        dbc.Button([html.I(className="fas fa-satellite me-2"), "Merging edge-on galaxy"],
-                                 id="example-1", className="example-button me-2 mb-2", size="sm", color="light"),
+                        dbc.Button([html.I(className="fas fa-clone me-2"), "Two edge-on galaxies"],
+                        id="example-1", className="example-button me-2 mb-2", size="sm", color="light"),
                         dbc.Button([html.I(className="fas fa-water me-2"), "Tidal"],
                                  id="example-2", className="example-button me-2 mb-2", size="sm", color="light"),
                         dbc.Button([html.I(className="fas fa-stream me-2"), "Stream"],
@@ -552,7 +552,7 @@ def create_search_container():
                                  id="example-5", className="example-button me-2 mb-2", size="sm", color="light"),
                         dbc.Button([html.I(className="fas fa-moon me-2"), "Low surface brightness"],
                                  id="example-6", className="example-button me-2 mb-2", size="sm", color="light"),
-                        dbc.Button([html.I(className="fas fa-ring me-2"), "Ring galaxy"],
+                        dbc.Button([html.I(className="fas fa-ring me-2"), "Ring-like structure"],
                                  id="example-7", className="example-button me-2 mb-2", size="sm", color="light"),
                         dbc.Button([html.I(className="fas fa-star me-2"), "A bursty, star forming galaxy"],
                                  id="example-8", className="example-button mb-2", size="sm", color="light")
@@ -699,7 +699,8 @@ def create_search_container():
     ], className="mb-3")
 
 
-def create_vector_input_row(index: int, query_type: str = "text", ra: float = None, dec: float = None, fov: float = 0.025):
+def create_vector_input_row(index: int, query_type: str = "text", ra: float = None, dec: float = None, fov: float = 0.025,
+                           text_value: str = None, operation: str = "+"):
     """Create a single vector input row with operation selector, query type toggle, and conditional inputs.
 
     Args:
@@ -708,6 +709,8 @@ def create_vector_input_row(index: int, query_type: str = "text", ra: float = No
         ra: Initial RA value for image queries (default: None)
         dec: Initial Dec value for image queries (default: None)
         fov: Initial FoV value for image queries (default: 0.025)
+        text_value: Initial text value for text queries (default: None)
+        operation: Initial operation value (default: "+")
 
     Returns:
         Dash Bootstrap Row component with text/image mode toggle
@@ -731,7 +734,7 @@ def create_vector_input_row(index: int, query_type: str = "text", ra: float = No
                     {"label": "-5", "value": "-5"},
                     {"label": "-10", "value": "-10"}
                 ],
-                value="+",
+                value=operation,
                 style={"width": "70px"},
                 className="d-inline-block vector-operation-select"
             )
@@ -756,7 +759,8 @@ def create_vector_input_row(index: int, query_type: str = "text", ra: float = No
                 dbc.Input(
                     id={"type": "vector-text", "index": index},
                     placeholder="Enter text query...",
-                    type="text"
+                    type="text",
+                    value=text_value
                 )
             ], id={"type": "text-input-container", "index": index}, style=text_display),
             # Image inputs (shown when type is "image")
@@ -810,9 +814,13 @@ def create_results_container():
 def create_stores():
     """Create Dash Store components for data persistence."""
     return [
+        dcc.Location(id='url', refresh=False),
         dcc.Store(id="search-data"),
         dcc.Store(id="current-galaxy-data"),
         dcc.Store(id="vector-inputs-count", data=1),
+        dcc.Store(id="current-search-params"),  # Stores current search params for URL generation
+        dcc.Store(id="pending-expand-galaxy"),  # Stores galaxy to expand after URL-based search
+        dcc.Store(id="url-search-trigger", data=0),  # Triggers search after URL state restore
         dcc.Download(id="download-csv")
     ]
 
@@ -832,6 +840,14 @@ def create_galaxy_modal():
                 color="primary",
                 className="me-2"
             ),
+            dbc.Button(
+                [html.I(className="fas fa-link me-2"), "Copy link"],
+                id="copy-galaxy-link",
+                color="secondary",
+                className="me-2",
+                n_clicks=0
+            ),
+            html.Span(id="copy-galaxy-feedback", style={"color": "#28a745", "fontSize": "0.8rem"}),
             dbc.Button("Close", id="close-modal", className="ms-auto")
         ])
     ], id="galaxy-modal", size="lg", is_open=False)

src/config.py

@@ -56,9 +56,16 @@ IMAGE_WIDTH = "100%"
 CUTOUT_FOV = 0.025
 CUTOUT_SIZE = 256
 
+# URL State Configuration
+URL_STATE_PARAM = "s"  # Query parameter name for encoded state
+
 # Logging Configuration
 VCU_COST_PER_MILLION = 4.0  # $4 per 1 million vCU
 
+# Hugging Face Dataset Logging
+HF_LOG_REPO_ID = os.getenv("HF_LOG_REPO_ID")  # e.g. "nolank/aionsearch-query-logs"
+HF_LOG_EVERY_MINUTES = int(os.getenv("HF_LOG_EVERY_MINUTES", "10"))
+
 # Feature Flags (for future features)
 FEATURE_IMAGE_SEARCH = False
 FEATURE_AUTH = False

src/hf_logging.py

@@ -0,0 +1,83 @@
+# src/hf_logging.py
+"""Hugging Face dataset logging with CommitScheduler."""
+
+import json
+import uuid
+import logging
+from pathlib import Path
+from datetime import datetime
+
+from huggingface_hub import CommitScheduler
+
+from src.config import HF_LOG_REPO_ID, HF_LOG_EVERY_MINUTES
+
+logger = logging.getLogger(__name__)
+
+# Generate a unique session ID for this app instance
+SESSION_ID = uuid.uuid4().hex
+
+# Initialize scheduler & local file if logging is configured
+if HF_LOG_REPO_ID:
+    feedback_file = Path("query_logs") / f"queries_{uuid.uuid4().hex}.jsonl"
+    feedback_folder = feedback_file.parent
+    feedback_folder.mkdir(parents=True, exist_ok=True)
+
+    scheduler = CommitScheduler(
+        repo_id=HF_LOG_REPO_ID,
+        repo_type="dataset",
+        folder_path=feedback_folder,
+        path_in_repo="data",             # files go in data/ on the dataset
+        every=HF_LOG_EVERY_MINUTES,      # in minutes
+    )
+
+    # Print initialization info
+    print("\n" + "="*80)
+    print("HF DATASET LOGGING INITIALIZED")
+    print("="*80)
+    print(f"Session ID: {SESSION_ID}")
+    print(f"Repository: {HF_LOG_REPO_ID}")
+    print(f"Local directory: {feedback_folder.absolute()}")
+    print(f"Local file: {feedback_file.name}")
+    print(f"Commit frequency: every {HF_LOG_EVERY_MINUTES} minutes")
+    print("="*80 + "\n")
+else:
+    scheduler = None
+    feedback_file = None
+    print("HF dataset logging disabled (HF_LOG_REPO_ID not set)")
+
+
+def log_query_event(payload: dict) -> None:
+    """Append one JSON log line that CommitScheduler will push to the Hub.
+
+    payload must be JSON-serializable. session_id and timestamp are added if missing.
+    No-op if HF_LOG_REPO_ID is not configured.
+
+    Expected payload fields:
+        - log_type: Type of event (aql_query, zilliz_query_stats, click_event)
+        - request_id: Unique ID for the request/search (optional, but recommended)
+        - session_id: Session ID (auto-added if missing)
+        - timestamp: ISO timestamp (auto-added if missing)
+        - error_occurred: Boolean indicating if an error occurred (optional)
+        - error_message: Error message if error_occurred is True (optional)
+        - error_type: Type of error (optional)
+        ... plus other event-specific fields
+    """
+    if scheduler is None or feedback_file is None:
+        return
+
+    # Auto-add session_id if not present
+    if "session_id" not in payload:
+        payload["session_id"] = SESSION_ID
+
+    # Auto-add timestamp if not present
+    if "timestamp" not in payload:
+        payload["timestamp"] = datetime.utcnow().isoformat()
+
+    try:
+        with scheduler.lock:
+            with feedback_file.open("a") as f:
+                f.write(json.dumps(payload))
+                f.write("\n")
+        print(f"✓ Logged to HF dataset: {payload.get('log_type', 'unknown')}")
+    except Exception as e:
+        logger.error(f"Failed to write query log locally: {e}")

src/url_state.py

@@ -0,0 +1,206 @@
+"""
+URL state encoding/decoding for shareable search URLs.
+
+Core principle: All searches are represented uniformly - basic search is just
+advanced search with a single text query at weight +1.
+"""
+
+import base64
+import json
+from typing import Dict, List, Optional, Tuple, Any
+
+try:
+    from flask import request
+except ImportError:
+    request = None
+
+
+def encode_search_state(
+    text_queries: List[str],
+    text_weights: List[float],
+    image_queries: List[Tuple[float, float, float]],  # (ra, dec, fov)
+    image_weights: List[float],
+    rmag_min: float = 13.0,
+    rmag_max: float = 20.0,
+    expand_galaxy: Optional[str] = None
+) -> str:
+    """
+    Encode search state into a compact base64 string.
+
+    Args:
+        text_queries: List of text query strings
+        text_weights: List of weights for text queries
+        image_queries: List of (ra, dec, fov) tuples
+        image_weights: List of weights for image queries
+        rmag_min: Minimum r-band magnitude (default 13.0)
+        rmag_max: Maximum r-band magnitude (default 20.0)
+        expand_galaxy: Optional object_id to expand in modal after search
+
+    Returns:
+        URL-safe base64 encoded string
+    """
+    state = {}
+
+    # Only include non-empty query arrays
+    if text_queries:
+        state["tq"] = text_queries
+        state["tw"] = text_weights
+
+    if image_queries:
+        state["iq"] = image_queries
+        state["iw"] = image_weights
+
+    # Only include magnitude limits if they differ from defaults
+    if rmag_min != 13.0:
+        state["rmin"] = rmag_min
+    if rmag_max != 20.0:
+        state["rmax"] = rmag_max
+
+    # Include expand galaxy if specified
+    if expand_galaxy:
+        state["exp"] = expand_galaxy
+
+    # Encode to JSON then base64 (URL-safe)
+    json_str = json.dumps(state, separators=(',', ':'))  # Compact JSON
+    encoded = base64.urlsafe_b64encode(json_str.encode('utf-8')).decode('utf-8')
+
+    # Remove padding (= characters) to make URL shorter - we'll add back on decode
+    return encoded.rstrip('=')
+
+
+def decode_search_state(encoded: str) -> Dict[str, Any]:
+    """
+    Decode a base64-encoded search state string.
+
+    Args:
+        encoded: URL-safe base64 encoded string
+
+    Returns:
+        Dictionary with full keys:
+        {
+            'text_queries': [...],
+            'text_weights': [...],
+            'image_queries': [...],
+            'image_weights': [...],
+            'rmag_min': float,
+            'rmag_max': float,
+            'expand_galaxy': str or None
+        }
+
+    Returns empty/default state if decoding fails.
+    """
+    # Default/empty state
+    default_state = {
+        'text_queries': [],
+        'text_weights': [],
+        'image_queries': [],
+        'image_weights': [],
+        'rmag_min': 13.0,
+        'rmag_max': 20.0,
+        'expand_galaxy': None
+    }
+
+    if not encoded:
+        return default_state
+
+    try:
+        # Add back padding if needed
+        padding = 4 - (len(encoded) % 4)
+        if padding != 4:
+            encoded += '=' * padding
+
+        # Decode from base64 then JSON
+        json_str = base64.urlsafe_b64decode(encoded.encode('utf-8')).decode('utf-8')
+        compact_state = json.loads(json_str)
+
+        # Expand compact keys to full keys
+        state = {
+            'text_queries': compact_state.get('tq', []),
+            'text_weights': compact_state.get('tw', []),
+            'image_queries': compact_state.get('iq', []),
+            'image_weights': compact_state.get('iw', []),
+            'rmag_min': compact_state.get('rmin', 13.0),
+            'rmag_max': compact_state.get('rmax', 20.0),
+            'expand_galaxy': compact_state.get('exp', None)
+        }
+
+        return state
+
+    except (ValueError, KeyError, json.JSONDecodeError, Exception):
+        # Silently fail and return empty state for any decode errors
+        return default_state
+
+
+def build_share_url(
+    text_queries: List[str],
+    text_weights: List[float],
+    image_queries: List[Tuple[float, float, float]],
+    image_weights: List[float],
+    rmag_min: float = 13.0,
+    rmag_max: float = 20.0,
+    expand_galaxy: Optional[str] = None
+) -> str:
+    """
+    Build a complete shareable URL for the current search state.
+
+    Args:
+        Same as encode_search_state()
+
+    Returns:
+        Complete URL like: https://app.com?s=<encoded_state>
+    """
+    from src.config import URL_STATE_PARAM
+
+    # Get base URL from Flask request context
+    try:
+        if request and hasattr(request, 'host_url'):
+            base_url = request.host_url.rstrip('/')
+        else:
+            base_url = "http://localhost:8050"
+    except (RuntimeError, AttributeError):
+        # If not in request context (e.g., during testing), use a placeholder
+        base_url = "http://localhost:8050"
+
+    # Encode the state
+    encoded = encode_search_state(
+        text_queries=text_queries,
+        text_weights=text_weights,
+        image_queries=image_queries,
+        image_weights=image_weights,
+        rmag_min=rmag_min,
+        rmag_max=rmag_max,
+        expand_galaxy=expand_galaxy
+    )
+
+    return f"{base_url}?{URL_STATE_PARAM}={encoded}"
+
+
+def parse_url_search_param(search_string: str) -> Dict[str, Any]:
+    """
+    Parse the search parameter from a URL query string.
+
+    Args:
+        search_string: The URL search/query string (e.g., "?s=eyJxdWVy...")
+
+    Returns:
+        Decoded state dictionary (same format as decode_search_state)
+    """
+    from src.config import URL_STATE_PARAM
+
+    if not search_string:
+        return decode_search_state("")
+
+    # Remove leading '?' if present
+    search_string = search_string.lstrip('?')
+
+    # Parse query parameters
+    params = {}
+    for param in search_string.split('&'):
+        if '=' in param:
+            key, value = param.split('=', 1)
+            params[key] = value
+
+    # Get the state parameter
+    encoded = params.get(URL_STATE_PARAM, '')
+
+    return decode_search_state(encoded)

src/utils.py

@@ -2,10 +2,12 @@
 
 import json
 import logging
+import uuid
 from pathlib import Path
 from datetime import datetime
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 from src.config import CUTOUT_FOV, CUTOUT_SIZE, VCU_COST_PER_MILLION
+from src.hf_logging import log_query_event, SESSION_ID
 
 logger = logging.getLogger(__name__)
 
@@ -34,9 +36,13 @@ def log_zilliz_query(
     query_info: Dict[str, Any],
     result_count: int,
     query_time: float,
-    cost_vcu: int = 0
+    cost_vcu: int = 0,
+    request_id: Optional[str] = None,
+    error_occurred: bool = False,
+    error_message: Optional[str] = None,
+    error_type: Optional[str] = None
 ) -> None:
-    """Print Zilliz query info to terminal instead of saving to file.
+    """Print Zilliz query info to terminal and log to HF dataset.
 
     Args:
         query_type: Type of query (e.g., "vector_search", "text_search")
@@ -44,6 +50,10 @@ def log_zilliz_query(
         result_count: Number of results returned
         query_time: Query execution time in seconds
         cost_vcu: Cost in vCU units
+        request_id: Unique ID for this request
+        error_occurred: Whether an error occurred
+        error_message: Error message if error_occurred is True
+        error_type: Type of error if error_occurred is True
     """
     timestamp = datetime.now().isoformat()
 
@@ -72,6 +82,29 @@ def log_zilliz_query(
         f"{cost_vcu} vCU (${cost_usd:.6f})"
     )
 
+    # Log Zilliz stats to HF dataset
+    try:
+        payload = {
+            "log_type": "zilliz_query_stats",
+            "timestamp": timestamp,
+            "query_type": query_type,
+            "query_info": query_info,
+            "result_count": result_count,
+            "query_time_seconds": query_time,
+            "cost_vcu": cost_vcu,
+            "cost_usd": cost_usd,
+            "error_occurred": error_occurred,
+        }
+        if request_id:
+            payload["request_id"] = request_id
+        if error_occurred:
+            payload["error_message"] = error_message
+            payload["error_type"] = error_type
+
+        log_query_event(payload)
+    except Exception as e:
+        logger.error(f"Failed to send Zilliz stats to HF dataset: {e}")
+
 
 def format_galaxy_count(count: int) -> str:
     """Format galaxy count with thousands separator.
@@ -104,69 +137,77 @@ def build_query_xml(
         rmag_max: Maximum r_mag filter value
 
     Returns:
-        XML string representation of the query
+        XML string representation of the query (single line)
     """
     xml_parts = ['<query>']
 
     # Add text queries
     if text_queries and len(text_queries) > 0:
-        xml_parts.append('  <text>')
+        xml_parts.append('<text>')
         for query, weight in zip(text_queries, text_weights):
-            xml_parts.append('    <term>')
-            xml_parts.append(f'      <weight>{weight}</weight>')
-            xml_parts.append(f'      <content>{query}</content>')
-            xml_parts.append('    </term>')
-        xml_parts.append('  </text>')
+            xml_parts.append('<term>')
+            xml_parts.append(f'<weight>{weight}</weight>')
+            xml_parts.append(f'<content>{query}</content>')
+            xml_parts.append('</term>')
+        xml_parts.append('</text>')
 
     # Add image queries
     if image_queries and len(image_queries) > 0:
-        xml_parts.append('  <image>')
+        xml_parts.append('<image>')
         for img_query, weight in zip(image_queries, image_weights):
-            xml_parts.append('    <reference>')
-            xml_parts.append(f'      <ra>{img_query["ra"]}</ra>')
-            xml_parts.append(f'      <dec>{img_query["dec"]}</dec>')
-            xml_parts.append(f'      <fov>{img_query["fov"]}</fov>')
-            xml_parts.append(f'      <weight>{weight}</weight>')
-            xml_parts.append('    </reference>')
-        xml_parts.append('  </image>')
+            xml_parts.append('<reference>')
+            xml_parts.append(f'<ra>{img_query["ra"]}</ra>')
+            xml_parts.append(f'<dec>{img_query["dec"]}</dec>')
+            xml_parts.append(f'<fov>{img_query["fov"]}</fov>')
+            xml_parts.append(f'<weight>{weight}</weight>')
+            xml_parts.append('</reference>')
+        xml_parts.append('</image>')
 
     # Add filters
     if rmag_min is not None or rmag_max is not None:
-        xml_parts.append('  <filters>')
+        xml_parts.append('<filters>')
         if rmag_min is not None and rmag_max is not None:
-            xml_parts.append('    <filter>')
-            xml_parts.append('      <column>r_mag</column>')
-            xml_parts.append('      <operator>between</operator>')
-            xml_parts.append(f'      <value_min>{rmag_min}</value_min>')
-            xml_parts.append(f'      <value_max>{rmag_max}</value_max>')
-            xml_parts.append('    </filter>')
+            xml_parts.append('<filter>')
+            xml_parts.append('<column>r_mag</column>')
+            xml_parts.append('<operator>between</operator>')
+            xml_parts.append(f'<value_min>{rmag_min}</value_min>')
+            xml_parts.append(f'<value_max>{rmag_max}</value_max>')
+            xml_parts.append('</filter>')
         elif rmag_min is not None:
-            xml_parts.append('    <filter>')
-            xml_parts.append('      <column>r_mag</column>')
-            xml_parts.append('      <operator>gte</operator>')
-            xml_parts.append(f'      <value>{rmag_min}</value>')
-            xml_parts.append('    </filter>')
+            xml_parts.append('<filter>')
+            xml_parts.append('<column>r_mag</column>')
+            xml_parts.append('<operator>gte</operator>')
+            xml_parts.append(f'<value>{rmag_min}</value>')
+            xml_parts.append('</filter>')
         elif rmag_max is not None:
-            xml_parts.append('    <filter>')
-            xml_parts.append('      <column>r_mag</column>')
-            xml_parts.append('      <operator>lte</operator>')
-            xml_parts.append(f'      <value>{rmag_max}</value>')
-            xml_parts.append('    </filter>')
-        xml_parts.append('  </filters>')
+            xml_parts.append('<filter>')
+            xml_parts.append('<column>r_mag</column>')
+            xml_parts.append('<operator>lte</operator>')
+            xml_parts.append(f'<value>{rmag_max}</value>')
+            xml_parts.append('</filter>')
+        xml_parts.append('</filters>')
 
     xml_parts.append('</query>')
-    return '\n'.join(xml_parts)
+    return ''.join(xml_parts)
 
 
 def log_query_to_csv(
     query_xml: str,
-    csv_path: str = "logs/query_log.csv"
+    csv_path: str = "logs/query_log.csv",
+    request_id: Optional[str] = None,
+    error_occurred: bool = False,
+    error_message: Optional[str] = None,
+    error_type: Optional[str] = None
 ) -> None:
-    """Print query XML to terminal instead of saving to file.
+    """Print query XML to terminal and log to HF dataset.
 
     Args:
         query_xml: XML string representation of the query
         csv_path: Deprecated parameter (kept for backward compatibility)
+        request_id: Unique ID for this request
+        error_occurred: Whether an error occurred during search
+        error_message: Error message if error_occurred is True
+        error_type: Type of error if error_occurred is True
     """
     timestamp = datetime.now().isoformat()
 
@@ -178,3 +219,60 @@ def log_query_to_csv(
     print("="*80 + "\n")
 
     logger.info(f"Query printed to terminal")
+
+    # Log to HF dataset
+    try:
+        payload = {
+            "log_type": "aql_query",
+            "timestamp": timestamp,
+            "query_xml": query_xml,
+            "error_occurred": error_occurred,
+        }
+        if request_id:
+            payload["request_id"] = request_id
+        if error_occurred:
+            payload["error_message"] = error_message
+            payload["error_type"] = error_type
+
+        log_query_event(payload)
+    except Exception as e:
+        logger.error(f"Failed to send query log to HF dataset: {e}")
+
+
+def log_click_event(
+    request_id: Optional[str],
+    rank: int,
+    primary_key: str,
+    ra: float,
+    dec: float,
+    r_mag: float,
+    distance: float
+) -> None:
+    """Log a galaxy tile click event to HF dataset.
+
+    Args:
+        request_id: Unique ID for the search request that produced this galaxy
+        rank: Position in search results (0-indexed)
+        primary_key: Primary key of the clicked galaxy
+        ra: Right ascension
+        dec: Declination
+        r_mag: r-band magnitude
+        distance: Cosine similarity score
+    """
+    try:
+        payload = {
+            "log_type": "click_event",
+            "rank": rank,
+            "primary_key": primary_key,
+            "ra": ra,
+            "dec": dec,
+            "r_mag": r_mag,
+            "distance": distance,
+        }
+        if request_id:
+            payload["request_id"] = request_id
+
+        log_query_event(payload)
+        logger.info(f"Logged click event: rank={rank}, primary_key={primary_key}")
+    except Exception as e:
+        logger.error(f"Failed to log click event: {e}")