new ui

app.py

@@ -1,141 +1,426 @@
+import os
+import tempfile
+from typing import Any
+
 import gradio as gr
 import httpx
 
-BASE_URL = "http://0.0.0.0:7860"
+
+# NOTE: 0.0.0.0 is a bind address, not a connect address.
+# Use 127.0.0.1 by default and allow overrides for deployments.
+BASE_URL = os.getenv("API_BASE_URL", "http://127.0.0.1:7860")
 
 
 def create_gradio_app():
     """Create and return the Gradio Blocks app for Music Memories."""
 
-    def add_song_fn(title, artist, album, duration, bpm, energy_level, lyrics):
+    def _maybe_int(value: Any) -> int | None:
+        if value is None:
+            return None
         try:
-            with httpx.Client() as client:
-                params = {"title": title, "artist": artist}
-                if album: params["album"] = album
-                if duration: params["duration"] = int(duration)
-                if bpm: params["bpm"] = int(bpm)
-                if energy_level: params["energy_level"] = int(energy_level)
-                if lyrics: params["lyrics"] = lyrics
-                resp = client.post(f"{BASE_URL}/songs", params=params, timeout=10.0)
-                resp.raise_for_status()
-                return "Success!", str(resp.json())
+            return int(value)
+        except Exception:
+            return None
+
+    def _json_request(
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+        follow_redirects: bool = True,
+        timeout: float = 15.0,
+    ) -> dict[str, Any]:
+        url = f"{BASE_URL}{path}"
+        with httpx.Client(follow_redirects=follow_redirects, timeout=timeout) as client:
+            resp = client.request(method, url, params=params, data=data, files=files)
+            resp.raise_for_status()
+            return resp.json()
+
+    def _redirect_location(path: str, *, params: dict[str, Any] | None = None) -> str:
+        url = f"{BASE_URL}{path}"
+        with httpx.Client(follow_redirects=False, timeout=15.0) as client:
+            resp = client.get(url, params=params)
+            if resp.status_code in (301, 302, 303, 307, 308):
+                return resp.headers.get("location") or ""
+            resp.raise_for_status()
+            return ""
+
+    def add_song_fn(title, artist, album, duration, bpm, energy_level, lyrics, audio_path):
+        try:
+            # /songs expects multipart/form-data (Form fields + optional file).
+            data: dict[str, Any] = {"title": title, "artist": artist}
+            if album:
+                data["album"] = album
+            duration_i = _maybe_int(duration)
+            if duration_i is not None:
+                data["duration"] = str(duration_i)
+            bpm_i = _maybe_int(bpm)
+            if bpm_i is not None:
+                data["bpm"] = str(bpm_i)
+            energy_i = _maybe_int(energy_level)
+            if energy_i is not None:
+                data["energy_level"] = str(energy_i)
+            if lyrics:
+                data["lyrics"] = lyrics
+
+            if audio_path:
+                filename = os.path.basename(str(audio_path))
+                with open(str(audio_path), "rb") as f:
+                    files = {"audio_file": (filename, f, "audio/mpeg")}
+                    out = _json_request("POST", "/songs", data=data, files=files)
+            else:
+                out = _json_request("POST", "/songs", data=data)
+
+            return "Success!", out
         except Exception as e:
-            return "Error", str(e)
+            return "Error", {"error": str(e)}
 
     def add_user_fn(name):
         try:
-            with httpx.Client() as client:
-                resp = client.post(f"{BASE_URL}/users", params={"name": name}, timeout=5.0)
-                resp.raise_for_status()
-                return "Success!", str(resp.json())
+            out = _json_request("POST", "/users", params={"name": name}, timeout=10.0)
+            return "Success!", out
         except Exception as e:
-            return "Error", str(e)
+            return "Error", {"error": str(e)}
 
     def add_memory_fn(user_id, description, date, song_id):
         try:
-            with httpx.Client() as client:
-                params = {"user_id": int(user_id), "description": description}
-                if date: params["date"] = date
-                if song_id: params["song_id"] = int(song_id)
-                resp = client.post(f"{BASE_URL}/memories", params=params, timeout=10.0)
-                resp.raise_for_status()
-                return "Success!", str(resp.json())
+            params: dict[str, Any] = {"user_id": _maybe_int(user_id), "description": description}
+            if params["user_id"] is None:
+                raise ValueError("user_id is required")
+            if date:
+                params["date"] = date
+            song_id_i = _maybe_int(song_id)
+            if song_id_i is not None:
+                params["song_id"] = song_id_i
+            out = _json_request("POST", "/memories", params=params)
+            return "Success!", out
         except Exception as e:
-            return "Error", str(e)
+            return "Error", {"error": str(e)}
 
     def add_playlist_fn(name, vibe_code, mood_description):
         try:
-            with httpx.Client() as client:
-                params = {"name": name}
-                if vibe_code: params["vibe_code"] = vibe_code
-                if mood_description: params["mood_description"] = mood_description
-                resp = client.post(f"{BASE_URL}/playlists", params=params, timeout=10.0)
-                resp.raise_for_status()
-                return "Success!", str(resp.json())
+            params: dict[str, Any] = {"name": name}
+            if vibe_code:
+                params["vibe_code"] = vibe_code
+            if mood_description:
+                params["mood_description"] = mood_description
+            out = _json_request("POST", "/playlists", params=params)
+            return "Success!", out
         except Exception as e:
-            return "Error", str(e)
+            return "Error", {"error": str(e)}
 
     def add_context_fn(weather, time_of_day, location_type):
         try:
-            with httpx.Client() as client:
-                params = {}
-                if weather: params["weather"] = weather
-                if time_of_day: params["time_of_day"] = time_of_day
-                if location_type: params["location_type"] = location_type
-                resp = client.post(f"{BASE_URL}/contexts", params=params, timeout=5.0)
-                resp.raise_for_status()
-                return "Success!", str(resp.json())
+            params: dict[str, Any] = {}
+            if weather:
+                params["weather"] = weather
+            if time_of_day:
+                params["time_of_day"] = time_of_day
+            if location_type:
+                params["location_type"] = location_type
+            out = _json_request("POST", "/contexts", params=params, timeout=10.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def get_song_fn(song_id):
+        try:
+            song_id_i = _maybe_int(song_id)
+            if song_id_i is None:
+                raise ValueError("song_id is required")
+            out = _json_request("GET", f"/songs/{song_id_i}")
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def delete_song_fn(song_id):
+        try:
+            song_id_i = _maybe_int(song_id)
+            if song_id_i is None:
+                raise ValueError("song_id is required")
+            out = _json_request("DELETE", f"/songs/{song_id_i}")
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def upload_song_audio_fn(song_id, audio_path):
+        try:
+            song_id_i = _maybe_int(song_id)
+            if song_id_i is None:
+                raise ValueError("song_id is required")
+            if not audio_path:
+                raise ValueError("audio file is required")
+            filename = os.path.basename(str(audio_path))
+            with open(str(audio_path), "rb") as f:
+                files = {"audio_file": (filename, f, "audio/mpeg")}
+                out = _json_request("POST", f"/songs/{song_id_i}/upload-audio", files=files)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def song_stream_url_fn(song_id):
+        try:
+            song_id_i = _maybe_int(song_id)
+            if song_id_i is None:
+                raise ValueError("song_id is required")
+            location = _redirect_location(f"/songs/{song_id_i}/stream")
+            if not location:
+                return "No redirect returned", ""
+            return "Success!", location
         except Exception as e:
             return "Error", str(e)
 
-    def search_songs_fn(query, n_results):
+    def song_download_fn(song_id):
         try:
-            with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/search/songs", params={"q": query, "n": n_results}, timeout=10.0)
+            song_id_i = _maybe_int(song_id)
+            if song_id_i is None:
+                raise ValueError("song_id is required")
+            url = f"{BASE_URL}/songs/{song_id_i}/download"
+            with httpx.Client(timeout=30.0) as client:
+                resp = client.get(url)
                 resp.raise_for_status()
-                data = resp.json()
-                results = data.get("results", [])
-                table = [[r["id"], r["title"], r["artist"], f"{r['distance']:.4f}"] for r in results] if results else []
-                return f"Found {len(results)} songs", table
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+                tmp.write(resp.content)
+                tmp.flush()
+                tmp.close()
+                return "Success!", tmp.name
+        except Exception as e:
+            return "Error", None
+
+    def get_user_fn(user_id):
+        try:
+            user_id_i = _maybe_int(user_id)
+            if user_id_i is None:
+                raise ValueError("user_id is required")
+            out = _json_request("GET", f"/users/{user_id_i}")
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def list_user_memories_fn(user_id):
+        try:
+            user_id_i = _maybe_int(user_id)
+            if user_id_i is None:
+                raise ValueError("user_id is required")
+            data = _json_request("GET", f"/users/{user_id_i}/memories", timeout=10.0)
+            memories = data.get("memories", [])
+            table = [[m.get("id"), m.get("user_id"), (m.get("description") or "")[:50], m.get("date", "")] for m in memories]
+            return f"Found {len(memories)} memories", table
+        except Exception as e:
+            return "Error", []
+
+    def user_activity_fn(user_id, limit, action_type):
+        try:
+            user_id_i = _maybe_int(user_id)
+            if user_id_i is None:
+                raise ValueError("user_id is required")
+            params: dict[str, Any] = {}
+            limit_i = _maybe_int(limit)
+            if limit_i is not None:
+                params["limit"] = limit_i
+            if action_type:
+                params["action_type"] = action_type
+            out = _json_request("GET", f"/users/{user_id_i}/activity", params=params)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def delete_playlist_fn(playlist_id):
+        try:
+            playlist_id_i = _maybe_int(playlist_id)
+            if playlist_id_i is None:
+                raise ValueError("playlist_id is required")
+            out = _json_request("DELETE", f"/playlists/{playlist_id_i}")
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def list_playlists_fn():
+        try:
+            data = _json_request("GET", "/playlists", timeout=10.0)
+            playlists = data.get("playlists", [])
+            return [[p.get("id"), p.get("name"), p.get("vibe_code", "")] for p in playlists]
+        except Exception as e:
+            return [["Error", str(e), ""]]
+
+    def delete_memory_fn(memory_id):
+        try:
+            memory_id_i = _maybe_int(memory_id)
+            if memory_id_i is None:
+                raise ValueError("memory_id is required")
+            out = _json_request("DELETE", f"/memories/{memory_id_i}")
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def list_contexts_fn():
+        try:
+            data = _json_request("GET", "/contexts", timeout=10.0)
+            contexts = data.get("contexts", [])
+            return [[c.get("id"), c.get("weather", ""), c.get("time_of_day", ""), c.get("location_type", "")] for c in contexts]
+        except Exception as e:
+            return [["Error", str(e), "", ""]]
+
+    def delete_context_fn(context_id):
+        try:
+            context_id_i = _maybe_int(context_id)
+            if context_id_i is None:
+                raise ValueError("context_id is required")
+            out = _json_request("DELETE", f"/contexts/{context_id_i}")
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def search_songs_fn(query, n_results):
+        try:
+            data = _json_request("GET", "/search/songs", params={"q": query, "n": n_results}, timeout=15.0)
+            results = data.get("results", [])
+            table = [[r.get("id"), r.get("title"), r.get("artist"), f"{float(r.get('distance', 0.0)):.4f}"] for r in results] if results else []
+            return f"Found {len(results)} songs", table
         except Exception as e:
             return "Error", []
 
     def search_memories_fn(query, n_results):
         try:
-            with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/search/memories", params={"q": query, "n": n_results}, timeout=10.0)
-                resp.raise_for_status()
-                data = resp.json()
-                results = data.get("results", [])
-                table = [[r["id"], r["user_id"], r["document"][:50], f"{r['distance']:.4f}"] for r in results] if results else []
-                return f"Found {len(results)} memories", table
+            data = _json_request("GET", "/search/memories", params={"q": query, "n": n_results}, timeout=15.0)
+            results = data.get("results", [])
+            table = [[r.get("id"), r.get("user_id"), (r.get("document") or "")[:50], f"{float(r.get('distance', 0.0)):.4f}"] for r in results] if results else []
+            return f"Found {len(results)} memories", table
         except Exception as e:
             return "Error", []
 
+    def search_contexts_fn(query, n_results):
+        try:
+            data = _json_request("GET", "/search/contexts", params={"q": query, "n": n_results}, timeout=15.0)
+            results = data.get("results", [])
+            table = [[r.get("id"), r.get("weather"), r.get("time_of_day"), r.get("location_type"), f"{float(r.get('distance', 0.0)):.4f}"] for r in results] if results else []
+            return f"Found {len(results)} contexts", table
+        except Exception:
+            return "Error", []
+
     def search_playlists_fn(query, n_results):
         try:
-            with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/search/playlists", params={"q": query, "n": n_results}, timeout=10.0)
-                resp.raise_for_status()
-                data = resp.json()
-                results = data.get("results", [])
-                table = [[r["id"], r["name"], f"{r['distance']:.4f}"] for r in results] if results else []
-                return f"Found {len(results)} playlists", table
+            data = _json_request("GET", "/search/playlists", params={"q": query, "n": n_results}, timeout=15.0)
+            results = data.get("results", [])
+            table = [[r.get("id"), r.get("name"), f"{float(r.get('distance', 0.0)):.4f}"] for r in results] if results else []
+            return f"Found {len(results)} playlists", table
         except Exception as e:
             return "Error", []
 
     def list_songs_fn():
         try:
-            with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/songs", timeout=5.0)
-                resp.raise_for_status()
-                data = resp.json()
-                songs = data.get("songs", [])
-                return [[s["id"], s["title"], s["artist"], s.get("album",""), s.get("bpm","")] for s in songs]
+            data = _json_request("GET", "/songs", timeout=10.0)
+            songs = data.get("songs", [])
+            return [[s.get("id"), s.get("title"), s.get("artist"), s.get("album", ""), s.get("bpm", ""), s.get("has_audio"), s.get("play_count")] for s in songs]
         except Exception as e:
-            return [["Error", str(e), "", "", ""]]
+            return [["Error", str(e), "", "", "", "", ""]]
 
     def list_users_fn():
         try:
-            with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/users", timeout=5.0)
-                resp.raise_for_status()
-                data = resp.json()
-                users = data.get("users", [])
-                return [[u["id"], u["name"], u.get("created_at","")] for u in users]
+            data = _json_request("GET", "/users", timeout=10.0)
+            users = data.get("users", [])
+            return [[u.get("id"), u.get("name"), u.get("created_at", "")] for u in users]
         except Exception as e:
             return [["Error", str(e), ""]]
 
     def list_memories_fn():
         try:
-            with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/memories", timeout=5.0)
-                resp.raise_for_status()
-                data = resp.json()
-                memories = data.get("memories", [])
-                return [[m["id"], m["user_id"], m["description"][:50], m.get("date","")] for m in memories]
+            data = _json_request("GET", "/memories", timeout=10.0)
+            memories = data.get("memories", [])
+            return [[m.get("id"), m.get("user_id"), (m.get("description") or "")[:50], m.get("date", ""), m.get("song_id", "")] for m in memories]
         except Exception as e:
-            return [["Error", str(e), "", ""]]
+            return [["Error", str(e), "", "", ""]]
+
+    def list_history_fn(user_id, limit):
+        try:
+            params: dict[str, Any] = {}
+            user_id_i = _maybe_int(user_id)
+            if user_id_i is not None:
+                params["user_id"] = user_id_i
+            limit_i = _maybe_int(limit)
+            if limit_i is not None:
+                params["limit"] = limit_i
+            out = _json_request("GET", "/history", params=params, timeout=20.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def add_history_fn(user_id, song_id, context_id, duration_seconds):
+        try:
+            params: dict[str, Any] = {}
+            user_id_i = _maybe_int(user_id)
+            song_id_i = _maybe_int(song_id)
+            if user_id_i is None or song_id_i is None:
+                raise ValueError("user_id and song_id are required")
+            params["user_id"] = user_id_i
+            params["song_id"] = song_id_i
+            context_id_i = _maybe_int(context_id)
+            if context_id_i is not None:
+                params["context_id"] = context_id_i
+            dur_i = _maybe_int(duration_seconds)
+            if dur_i is not None:
+                params["duration_seconds"] = dur_i
+            out = _json_request("POST", "/history", params=params, timeout=20.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def analytics_summary_fn(hours):
+        try:
+            hours_i = _maybe_int(hours)
+            params = {"hours": hours_i} if hours_i is not None else {}
+            out = _json_request("GET", "/analytics/summary", params=params, timeout=20.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def analytics_top_songs_fn(limit):
+        try:
+            limit_i = _maybe_int(limit)
+            params = {"limit": limit_i} if limit_i is not None else {}
+            out = _json_request("GET", "/analytics/top-songs", params=params, timeout=20.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def analytics_popular_searches_fn(hours, limit):
+        try:
+            params: dict[str, Any] = {}
+            hours_i = _maybe_int(hours)
+            limit_i = _maybe_int(limit)
+            if hours_i is not None:
+                params["hours"] = hours_i
+            if limit_i is not None:
+                params["limit"] = limit_i
+            out = _json_request("GET", "/analytics/popular-searches", params=params, timeout=20.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def storage_files_fn():
+        try:
+            out = _json_request("GET", "/storage/files", timeout=20.0)
+            files = out.get("files", [])
+            table = [[f.get("object_name"), f.get("size"), f.get("last_modified")] for f in files]
+            return f"Found {len(files)} files", table
+        except Exception as e:
+            return "Error", []
+
+    def health_fn():
+        try:
+            out = _json_request("GET", "/health", timeout=10.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
+
+    def root_fn():
+        try:
+            out = _json_request("GET", "/", timeout=10.0)
+            return "Success!", out
+        except Exception as e:
+            return "Error", {"error": str(e)}
 
     with gr.Blocks(title="Music Memories UI") as demo:
         gr.Markdown("# 🎵 Music Memories")
@@ -151,14 +436,52 @@ def create_gradio_app():
                 song_bpm = gr.Number(label="BPM", precision=0)
                 song_energy = gr.Slider(1, 10, value=5, label="Energy Level")
                 song_lyrics = gr.Textbox(label="Lyrics", placeholder="Lyrics for semantic search", lines=3)
+                song_audio = gr.File(label="Audio File (MP3, optional)", file_types=[".mp3"], type="filepath")
                 song_add_btn = gr.Button("Add Song")
                 song_add_status = gr.Textbox(label="Status")
                 song_add_output = gr.JSON(label="Response")
-                song_add_btn.click(fn=add_song_fn, inputs=[song_title, song_artist, song_album, song_duration, song_bpm, song_energy, song_lyrics], outputs=[song_add_status, song_add_output])
+                song_add_btn.click(
+                    fn=add_song_fn,
+                    inputs=[song_title, song_artist, song_album, song_duration, song_bpm, song_energy, song_lyrics, song_audio],
+                    outputs=[song_add_status, song_add_output],
+                )
+
+            with gr.Group():
+                gr.Markdown("### Get / Delete Song")
+                song_id = gr.Number(label="Song ID", precision=0)
+                song_get_btn = gr.Button("Get Song")
+                song_del_btn = gr.Button("Delete Song")
+                song_action_status = gr.Textbox(label="Status")
+                song_action_output = gr.JSON(label="Response")
+                song_get_btn.click(fn=get_song_fn, inputs=[song_id], outputs=[song_action_status, song_action_output])
+                song_del_btn.click(fn=delete_song_fn, inputs=[song_id], outputs=[song_action_status, song_action_output])
+
+            with gr.Group():
+                gr.Markdown("### Audio: Upload / Stream / Download")
+                audio_song_id = gr.Number(label="Song ID", precision=0)
+                audio_upload = gr.File(label="MP3 File", file_types=[".mp3"], type="filepath")
+                audio_upload_btn = gr.Button("Upload/Update Audio")
+                audio_upload_status = gr.Textbox(label="Status")
+                audio_upload_output = gr.JSON(label="Response")
+                audio_upload_btn.click(
+                    fn=upload_song_audio_fn,
+                    inputs=[audio_song_id, audio_upload],
+                    outputs=[audio_upload_status, audio_upload_output],
+                )
+
+                stream_btn = gr.Button("Get Stream URL")
+                stream_status = gr.Textbox(label="Status")
+                stream_url = gr.Textbox(label="Presigned Stream URL")
+                stream_btn.click(fn=song_stream_url_fn, inputs=[audio_song_id], outputs=[stream_status, stream_url])
+
+                download_btn = gr.Button("Download MP3 via API")
+                download_status = gr.Textbox(label="Status")
+                download_file = gr.File(label="Downloaded File")
+                download_btn.click(fn=song_download_fn, inputs=[audio_song_id], outputs=[download_status, download_file])
             
             with gr.Group():
                 gr.Markdown("### All Songs")
-                songs_table = gr.Dataframe(headers=["ID", "Title", "Artist", "Album", "BPM"], label="Songs")
+                songs_table = gr.Dataframe(headers=["ID", "Title", "Artist", "Album", "BPM", "Has Audio", "Play Count"], label="Songs")
                 songs_load_btn = gr.Button("Load Songs")
                 songs_load_btn.click(fn=list_songs_fn, outputs=songs_table)
 
@@ -170,6 +493,32 @@ def create_gradio_app():
                 user_add_status = gr.Textbox(label="Status")
                 user_add_output = gr.JSON(label="Response")
                 user_add_btn.click(fn=add_user_fn, inputs=user_name, outputs=[user_add_status, user_add_output])
+
+            with gr.Group():
+                gr.Markdown("### Get User")
+                get_user_id = gr.Number(label="User ID", precision=0)
+                get_user_btn = gr.Button("Get User")
+                get_user_status = gr.Textbox(label="Status")
+                get_user_output = gr.JSON(label="Response")
+                get_user_btn.click(fn=get_user_fn, inputs=[get_user_id], outputs=[get_user_status, get_user_output])
+
+            with gr.Group():
+                gr.Markdown("### User Memories")
+                um_user_id = gr.Number(label="User ID", precision=0)
+                um_btn = gr.Button("Load User Memories")
+                um_summary = gr.Textbox(label="Results")
+                um_table = gr.Dataframe(headers=["ID", "User ID", "Description", "Date"], label="Memories")
+                um_btn.click(fn=list_user_memories_fn, inputs=[um_user_id], outputs=[um_summary, um_table])
+
+            with gr.Group():
+                gr.Markdown("### User Activity")
+                ua_user_id = gr.Number(label="User ID", precision=0)
+                ua_limit = gr.Number(label="Limit", value=50, precision=0)
+                ua_action_type = gr.Textbox(label="Action Type (optional)")
+                ua_btn = gr.Button("Load Activity")
+                ua_status = gr.Textbox(label="Status")
+                ua_output = gr.JSON(label="Response")
+                ua_btn.click(fn=user_activity_fn, inputs=[ua_user_id, ua_limit, ua_action_type], outputs=[ua_status, ua_output])
             
             with gr.Group():
                 gr.Markdown("### All Users")
@@ -188,10 +537,18 @@ def create_gradio_app():
                 mem_add_status = gr.Textbox(label="Status")
                 mem_add_output = gr.JSON(label="Response")
                 mem_add_btn.click(fn=add_memory_fn, inputs=[mem_user_id, mem_desc, mem_date, mem_song_id], outputs=[mem_add_status, mem_add_output])
+
+            with gr.Group():
+                gr.Markdown("### Delete Memory")
+                del_mem_id = gr.Number(label="Memory ID", precision=0)
+                del_mem_btn = gr.Button("Delete")
+                del_mem_status = gr.Textbox(label="Status")
+                del_mem_output = gr.JSON(label="Response")
+                del_mem_btn.click(fn=delete_memory_fn, inputs=[del_mem_id], outputs=[del_mem_status, del_mem_output])
             
             with gr.Group():
                 gr.Markdown("### All Memories")
-                memories_table = gr.Dataframe(headers=["ID", "User ID", "Description", "Date"], label="Memories")
+                memories_table = gr.Dataframe(headers=["ID", "User ID", "Description", "Date", "Song ID"], label="Memories")
                 memories_load_btn = gr.Button("Load Memories")
                 memories_load_btn.click(fn=list_memories_fn, outputs=memories_table)
 
@@ -206,6 +563,20 @@ def create_gradio_app():
                 pl_add_output = gr.JSON(label="Response")
                 pl_add_btn.click(fn=add_playlist_fn, inputs=[pl_name, pl_vibe, pl_mood], outputs=[pl_add_status, pl_add_output])
 
+            with gr.Group():
+                gr.Markdown("### All Playlists")
+                playlists_table = gr.Dataframe(headers=["ID", "Name", "Vibe Code"], label="Playlists")
+                playlists_load_btn = gr.Button("Load Playlists")
+                playlists_load_btn.click(fn=list_playlists_fn, outputs=playlists_table)
+
+            with gr.Group():
+                gr.Markdown("### Delete Playlist")
+                del_pl_id = gr.Number(label="Playlist ID", precision=0)
+                del_pl_btn = gr.Button("Delete")
+                del_pl_status = gr.Textbox(label="Status")
+                del_pl_output = gr.JSON(label="Response")
+                del_pl_btn.click(fn=delete_playlist_fn, inputs=[del_pl_id], outputs=[del_pl_status, del_pl_output])
+
         with gr.Tab("🌤️ Contexts"):
             with gr.Group():
                 gr.Markdown("### Add Context")
@@ -217,6 +588,20 @@ def create_gradio_app():
                 ctx_add_output = gr.JSON(label="Response")
                 ctx_add_btn.click(fn=add_context_fn, inputs=[ctx_weather, ctx_time, ctx_location], outputs=[ctx_add_status, ctx_add_output])
 
+            with gr.Group():
+                gr.Markdown("### All Contexts")
+                ctx_table = gr.Dataframe(headers=["ID", "Weather", "Time of Day", "Location"], label="Contexts")
+                ctx_load_btn = gr.Button("Load Contexts")
+                ctx_load_btn.click(fn=list_contexts_fn, outputs=ctx_table)
+
+            with gr.Group():
+                gr.Markdown("### Delete Context")
+                del_ctx_id = gr.Number(label="Context ID", precision=0)
+                del_ctx_btn = gr.Button("Delete")
+                del_ctx_status = gr.Textbox(label="Status")
+                del_ctx_output = gr.JSON(label="Response")
+                del_ctx_btn.click(fn=delete_context_fn, inputs=[del_ctx_id], outputs=[del_ctx_status, del_ctx_output])
+
         with gr.Tab("🔍 Semantic Search"):
             with gr.Group():
                 gr.Markdown("### Search Songs by Vibe")
@@ -235,6 +620,15 @@ def create_gradio_app():
                 search_mem_summary = gr.Textbox(label="Results")
                 search_mem_table = gr.Dataframe(headers=["ID", "User ID", "Description", "Distance"], label="Memories")
                 search_mem_btn.click(fn=search_memories_fn, inputs=[search_mem_query, search_mem_n], outputs=[search_mem_summary, search_mem_table])
+
+            with gr.Group():
+                gr.Markdown("### Search Contexts")
+                search_ctx_query = gr.Textbox(label="Query", placeholder="e.g., 'rainy night drive', 'sunny beach'")
+                search_ctx_n = gr.Slider(1, 20, value=5, step=1, label="Results")
+                search_ctx_btn = gr.Button("Search")
+                search_ctx_summary = gr.Textbox(label="Results")
+                search_ctx_table = gr.Dataframe(headers=["ID", "Weather", "Time", "Location", "Distance"], label="Contexts")
+                search_ctx_btn.click(fn=search_contexts_fn, inputs=[search_ctx_query, search_ctx_n], outputs=[search_ctx_summary, search_ctx_table])
             
             with gr.Group():
                 gr.Markdown("### Search Playlists by Mood")
@@ -246,9 +640,77 @@ def create_gradio_app():
                 search_pl_btn.click(fn=search_playlists_fn, inputs=[search_pl_query, search_pl_n], outputs=[search_pl_summary, search_pl_table])
 
         with gr.Tab("ℹ️ Health"):
-            health_output = gr.JSON(label="Health Status")
-            health_btn = gr.Button("Check Health")
-            health_btn.click(fn=lambda: {"status": "healthy", "app": "Music Memories"}, outputs=health_output)
+            with gr.Group():
+                gr.Markdown("### Root")
+                root_btn = gr.Button("GET /")
+                root_status = gr.Textbox(label="Status")
+                root_output = gr.JSON(label="Response")
+                root_btn.click(fn=root_fn, outputs=[root_status, root_output])
+
+            with gr.Group():
+                gr.Markdown("### Health")
+                health_btn = gr.Button("GET /health")
+                health_status = gr.Textbox(label="Status")
+                health_output = gr.JSON(label="Response")
+                health_btn.click(fn=health_fn, outputs=[health_status, health_output])
+
+        with gr.Tab("▶️ History"):
+            with gr.Group():
+                gr.Markdown("### List History")
+                hist_user_id = gr.Number(label="User ID (optional)", precision=0)
+                hist_limit = gr.Number(label="Limit", value=50, precision=0)
+                hist_list_btn = gr.Button("Load History")
+                hist_status = gr.Textbox(label="Status")
+                hist_output = gr.JSON(label="Response")
+                hist_list_btn.click(fn=list_history_fn, inputs=[hist_user_id, hist_limit], outputs=[hist_status, hist_output])
+
+            with gr.Group():
+                gr.Markdown("### Add Play Event")
+                hist_add_user = gr.Number(label="User ID", precision=0)
+                hist_add_song = gr.Number(label="Song ID", precision=0)
+                hist_add_ctx = gr.Number(label="Context ID (optional)", precision=0)
+                hist_add_dur = gr.Number(label="Duration Seconds (optional)", precision=0)
+                hist_add_btn = gr.Button("Add History")
+                hist_add_status = gr.Textbox(label="Status")
+                hist_add_output = gr.JSON(label="Response")
+                hist_add_btn.click(
+                    fn=add_history_fn,
+                    inputs=[hist_add_user, hist_add_song, hist_add_ctx, hist_add_dur],
+                    outputs=[hist_add_status, hist_add_output],
+                )
+
+        with gr.Tab("📊 Analytics"):
+            with gr.Group():
+                gr.Markdown("### Summary")
+                an_hours = gr.Number(label="Hours", value=24, precision=0)
+                an_sum_btn = gr.Button("Get Summary")
+                an_sum_status = gr.Textbox(label="Status")
+                an_sum_output = gr.JSON(label="Response")
+                an_sum_btn.click(fn=analytics_summary_fn, inputs=[an_hours], outputs=[an_sum_status, an_sum_output])
+
+            with gr.Group():
+                gr.Markdown("### Top Songs")
+                an_limit = gr.Number(label="Limit", value=10, precision=0)
+                an_top_btn = gr.Button("Get Top Songs")
+                an_top_status = gr.Textbox(label="Status")
+                an_top_output = gr.JSON(label="Response")
+                an_top_btn.click(fn=analytics_top_songs_fn, inputs=[an_limit], outputs=[an_top_status, an_top_output])
+
+            with gr.Group():
+                gr.Markdown("### Popular Searches")
+                ps_hours = gr.Number(label="Hours", value=24, precision=0)
+                ps_limit = gr.Number(label="Limit", value=10, precision=0)
+                ps_btn = gr.Button("Get Popular Searches")
+                ps_status = gr.Textbox(label="Status")
+                ps_output = gr.JSON(label="Response")
+                ps_btn.click(fn=analytics_popular_searches_fn, inputs=[ps_hours, ps_limit], outputs=[ps_status, ps_output])
+
+            with gr.Group():
+                gr.Markdown("### Storage Files")
+                sf_btn = gr.Button("List MP3 Files")
+                sf_summary = gr.Textbox(label="Results")
+                sf_table = gr.Dataframe(headers=["Object", "Size", "Last Modified"], label="Files")
+                sf_btn.click(fn=storage_files_fn, outputs=[sf_summary, sf_table])
 
     return demo