workign 2 dbs need toe be in server

.dockerignore

@@ -0,0 +1,73 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+*.egg
+
+# Virtual environments (BIG!)
+.venv/
+venv/
+ENV/
+env/
+
+# Database files (seeded at build time for consistency)
+music_memories.db
+*.db
+*.sqlite
+*.sqlite3
+
+# ChromaDB (regenerate on build)
+chroma_db/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Jupyter
+.ipynb_checkpoints
+
+# ML models (too big)
+*.pth
+*.pt
+*.onnx
+*.pb
+*.h5
+*.pkl
+*.pickle
+*.ckpt
+*.safetensors
+saved_model/
+
+# Logs
+*.log
+logs/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Git
+.git/
+.gitignore
+
+# Docker
+Dockerfile
+docker-compose*.yml
+
+# Documentation (not needed in image)
+*.md
+!README.md

.gitignore

@@ -85,3 +85,4 @@ uv.lock
 # Local development
 *.local
 *.dev
+

Dockerfile

@@ -9,6 +9,8 @@ USER user
 
 # uv installs binaries into ~/.local/bin
 ENV PATH="/home/user/.local/bin:/app/.venv/bin:$PATH"
+ENV CHROMA_DB_HOST_IP="127.0.0.1"
+ENV ANONYMIZED_TELEMETRY="false"
 WORKDIR /app
 
 # Install uv (dependency manager)
@@ -24,6 +26,12 @@ RUN uv venv /app/.venv \
 # Copy the rest of the app
 COPY --chown=user . /app
 
+# Ensure data directories exist and are writable
+RUN mkdir -p /app/chroma_db /app/data && chown -R user:user /app/chroma_db /app/data
+
+# Seed the database (consistent data in every container)
+RUN uv run python seed_db.py
+
 EXPOSE 7860
 
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,120 @@
----
-title: Pool
-emoji: 🌍
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎵 Music Memories
+
+A music library and memory management app with semantic search powered by ChromaDB and SQLite.
+
+## Features
+
+- **Songs** - Store songs with metadata (title, artist, album, BPM, energy level) and lyrics
+- **Users** - Manage user accounts
+- **Memories** - Link memories to songs and users
+- **Playlists** - Create playlists with mood descriptions
+- **Contexts** - Track listening contexts (weather, time, location)
+- **Play History** - Log listening history
+- **Semantic Search** - Search songs, memories, and playlists by vibe/mood using AI embeddings
+
+## Tech Stack
+
+- **FastAPI** - REST API
+- **SQLite** - Permanent storage for all data
+- **ChromaDB** - Semantic search embeddings
+- **Sentence Transformers** - all-MiniLM-L6-v2 for embeddings
+- **Gradio** - Web UI
+
+## API Endpoints
+
+### Songs
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/songs` | List all songs |
+| GET | `/songs/{id}` | Get song by ID |
+| POST | `/songs?title=X&artist=Y&lyrics=Z` | Add song |
+| DELETE | `/songs/{id}` | Delete song |
+
+### Users
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/users` | List all users |
+| GET | `/users/{id}` | Get user by ID |
+| POST | `/users?name=X` | Add user |
+
+### Memories
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/memories` | List all memories |
+| GET | `/users/{id}/memories` | Get user's memories |
+| POST | `/memories?user_id=X&description=Y` | Add memory |
+| DELETE | `/memories/{id}` | Delete memory |
+
+### Playlists
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/playlists` | List all playlists |
+| POST | `/playlists?name=X&mood_description=Y` | Add playlist |
+| DELETE | `/playlists/{id}` | Delete playlist |
+
+### Contexts
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/contexts` | List all contexts |
+| POST | `/contexts?weather=X&time_of_day=Y` | Add context |
+| DELETE | `/contexts/{id}` | Delete context |
+
+### Play History
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/history?user_id=X` | Get play history |
+| POST | `/history?user_id=X&song_id=Y` | Add play entry |
+
+### Semantic Search
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/search/songs?q=query&n=5` | Search songs by vibe |
+| GET | `/search/memories?q=query&n=5` | Search memories |
+| GET | `/search/playlists?q=query&n=5` | Search playlists by mood |
+| GET | `/search/contexts?q=query&n=5` | Search contexts |
+
+## Example Usage
+
+```bash
+# Add a user
+curl -X POST "http://localhost:7860/users?name=Alice"
+
+# Add a song with lyrics for semantic search
+curl -X POST "http://localhost:7860/songs?title=Midnight%20Rain&artist=Taylor%20Swift&energy_level=6&lyrics=He%20wanted%20it%20comfortable%20quiet%20life"
+
+# Add a memory
+curl -X POST "http://localhost:7860/memories?user_id=1&description=Dancing in the rain on our first date&song_id=1"
+
+# Search songs by vibe
+curl "http://localhost:7860/search/songs?q=sad%20breakup&n=5"
+
+# Search memories
+curl "http://localhost:7860/search/memories?q=romantic%20evening&n=5"
+
+# Search playlists by mood
+curl "http://localhost:7860/search/playlists?q=chill%20evening%20vibes&n=5"
+```
+
+## Run Locally
+
+```bash
+# Install dependencies
+uv sync
+
+# Run the server
+uvicorn main:app --host 0.0.0.0 --port 7860
+```
+
+Visit `http://localhost:7860/ui` for the web interface.
+
+## Docker
+
+```bash
+docker build -t music-memories .
+docker run -p 7860:7860 -v ./data:/app/data music-memories
+```
+
+## Data Storage
+
+- **SQLite**: `music_memories.db` - All structured data
+- **ChromaDB**: `chroma_db/` - Semantic search embeddings

app.py

@@ -5,63 +5,250 @@ BASE_URL = "http://0.0.0.0:7860"
 
 
 def create_gradio_app():
-    """Create and return the Gradio Blocks app that calls the FastAPI backend."""
-    
-    def greet(name):
-        """Call the greeting endpoint."""
+    """Create and return the Gradio Blocks app for Music Memories."""
+
+    def add_song_fn(title, artist, album, duration, bpm, energy_level, lyrics):
+        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())
+        except Exception as e:
+            return "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())
+        except Exception as e:
+            return "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())
+        except Exception as e:
+            return "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())
+        except Exception as e:
+            return "Error", str(e)
+
+    def add_context_fn(weather, time_of_day, location_type):
         try:
             with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/", timeout=5.0)
+                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())
+        except Exception as e:
+            return "Error", str(e)
+
+    def search_songs_fn(query, n_results):
+        try:
+            with httpx.Client() as client:
+                resp = client.get(f"{BASE_URL}/search/songs", params={"q": query, "n": n_results}, timeout=10.0)
                 resp.raise_for_status()
                 data = resp.json()
-                return f"{data['Hello']}, {name}! Welcome to Pool API."
+                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
         except Exception as e:
-            return f"Error: {str(e)}"
+            return "Error", []
 
-    def load_products():
-        """Call the products endpoint."""
+    def search_memories_fn(query, n_results):
         try:
             with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/products", timeout=5.0)
+                resp = client.get(f"{BASE_URL}/search/memories", params={"q": query, "n": n_results}, timeout=10.0)
                 resp.raise_for_status()
                 data = resp.json()
-                return [[p["id"], p["name"], p["price"], p["category"]] for p in data["products"]]
+                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
         except Exception as e:
-            return [["Error", str(e), "", ""]]
+            return "Error", []
 
-    def check_health():
-        """Call the health endpoint."""
+    def search_playlists_fn(query, n_results):
         try:
             with httpx.Client() as client:
-                resp = client.get(f"{BASE_URL}/health", timeout=5.0)
+                resp = client.get(f"{BASE_URL}/search/playlists", params={"q": query, "n": n_results}, timeout=10.0)
                 resp.raise_for_status()
-                return resp.json()
+                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
         except Exception as e:
-            return {"error": str(e)}
-
-    with gr.Blocks(title="Pool UI") as demo:
-        gr.Markdown("# 🌍 Pool API - Gradio UI")
-        gr.Markdown("Interact with the Pool API endpoints below.")
-        
-        with gr.Tab("Greeting"):
-            name_input = gr.Textbox(label="Enter your name", placeholder="Type your name here...")
-            greet_btn = gr.Button("Greet")
-            greet_output = gr.Textbox(label="Response")
-            greet_btn.click(fn=greet, inputs=name_input, outputs=greet_output)
-        
-        with gr.Tab("Products"):
-            products_table = gr.Dataframe(
-                headers=["ID", "Name", "Price", "Category"],
-                datatype=["number", "str", "number", "str"],
-                label="Product List"
-            )
-            load_btn = gr.Button("Load Products")
-            load_btn.click(fn=load_products, outputs=products_table)
-        
-        with gr.Tab("Health Check"):
+            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]
+        except Exception as 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]
+        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]
+        except Exception as e:
+            return [["Error", str(e), "", ""]]
+
+    with gr.Blocks(title="Music Memories UI") as demo:
+        gr.Markdown("# 🎵 Music Memories")
+        gr.Markdown("Manage your music library, memories, and playlists with semantic search.")
+
+        with gr.Tab("🎶 Songs"):
+            with gr.Group():
+                gr.Markdown("### Add Song")
+                song_title = gr.Textbox(label="Title", placeholder="Song title")
+                song_artist = gr.Textbox(label="Artist", placeholder="Artist name")
+                song_album = gr.Textbox(label="Album", placeholder="Album (optional)")
+                song_duration = gr.Number(label="Duration (seconds)", precision=0)
+                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_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])
+            
+            with gr.Group():
+                gr.Markdown("### All Songs")
+                songs_table = gr.Dataframe(headers=["ID", "Title", "Artist", "Album", "BPM"], label="Songs")
+                songs_load_btn = gr.Button("Load Songs")
+                songs_load_btn.click(fn=list_songs_fn, outputs=songs_table)
+
+        with gr.Tab("👤 Users"):
+            with gr.Group():
+                gr.Markdown("### Add User")
+                user_name = gr.Textbox(label="Name", placeholder="User name")
+                user_add_btn = gr.Button("Add User")
+                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("### All Users")
+                users_table = gr.Dataframe(headers=["ID", "Name", "Created At"], label="Users")
+                users_load_btn = gr.Button("Load Users")
+                users_load_btn.click(fn=list_users_fn, outputs=users_table)
+
+        with gr.Tab("💭 Memories"):
+            with gr.Group():
+                gr.Markdown("### Add Memory")
+                mem_user_id = gr.Number(label="User ID", precision=0)
+                mem_desc = gr.Textbox(label="Description", placeholder="Describe the memory...", lines=2)
+                mem_date = gr.Textbox(label="Date (optional)", placeholder="YYYY-MM-DD")
+                mem_song_id = gr.Number(label="Song ID (optional)", precision=0)
+                mem_add_btn = gr.Button("Add Memory")
+                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("### All Memories")
+                memories_table = gr.Dataframe(headers=["ID", "User ID", "Description", "Date"], label="Memories")
+                memories_load_btn = gr.Button("Load Memories")
+                memories_load_btn.click(fn=list_memories_fn, outputs=memories_table)
+
+        with gr.Tab("🎵 Playlists"):
+            with gr.Group():
+                gr.Markdown("### Add Playlist")
+                pl_name = gr.Textbox(label="Name", placeholder="Playlist name")
+                pl_vibe = gr.Textbox(label="Vibe Code", placeholder="e.g., chill, energetic")
+                pl_mood = gr.Textbox(label="Mood Description", placeholder="Describe the mood journey...", lines=2)
+                pl_add_btn = gr.Button("Add Playlist")
+                pl_add_status = gr.Textbox(label="Status")
+                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.Tab("🌤️ Contexts"):
+            with gr.Group():
+                gr.Markdown("### Add Context")
+                ctx_weather = gr.Textbox(label="Weather", placeholder="e.g., rainy, sunny")
+                ctx_time = gr.Textbox(label="Time of Day", placeholder="e.g., morning, night")
+                ctx_location = gr.Textbox(label="Location Type", placeholder="e.g., home, gym, car")
+                ctx_add_btn = gr.Button("Add Context")
+                ctx_add_status = gr.Textbox(label="Status")
+                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.Tab("🔍 Semantic Search"):
+            with gr.Group():
+                gr.Markdown("### Search Songs by Vibe")
+                search_songs_query = gr.Textbox(label="Query", placeholder="e.g., 'sad breakup song', 'workout energy'")
+                search_songs_n = gr.Slider(1, 20, value=5, step=1, label="Results")
+                search_songs_btn = gr.Button("Search")
+                search_songs_summary = gr.Textbox(label="Results")
+                search_songs_table = gr.Dataframe(headers=["ID", "Title", "Artist", "Distance"], label="Songs")
+                search_songs_btn.click(fn=search_songs_fn, inputs=[search_songs_query, search_songs_n], outputs=[search_songs_summary, search_songs_table])
+            
+            with gr.Group():
+                gr.Markdown("### Search Memories")
+                search_mem_query = gr.Textbox(label="Query", placeholder="e.g., 'summer road trip', 'first dance'")
+                search_mem_n = gr.Slider(1, 20, value=5, step=1, label="Results")
+                search_mem_btn = gr.Button("Search")
+                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 Playlists by Mood")
+                search_pl_query = gr.Textbox(label="Query", placeholder="e.g., 'chill evening vibes', 'party energy'")
+                search_pl_n = gr.Slider(1, 20, value=5, step=1, label="Results")
+                search_pl_btn = gr.Button("Search")
+                search_pl_summary = gr.Textbox(label="Results")
+                search_pl_table = gr.Dataframe(headers=["ID", "Name", "Distance"], label="Playlists")
+                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=check_health, outputs=health_output)
+            health_btn.click(fn=lambda: {"status": "healthy", "app": "Music Memories"}, outputs=health_output)
 
     return demo
 

database.py

@@ -0,0 +1,296 @@
+"""SQLite database module for music memories app."""
+
+import sqlite3
+from contextlib import contextmanager
+from datetime import datetime
+from typing import Optional
+
+DATABASE_PATH = "./music_memories.db"
+
+
+@contextmanager
+def get_db_connection():
+    """Get a database connection with row factory."""
+    conn = sqlite3.connect(DATABASE_PATH)
+    conn.row_factory = sqlite3.Row
+    try:
+        yield conn
+    finally:
+        conn.close()
+
+
+def init_database() -> None:
+    """Initialize the SQLite database with all tables."""
+    with get_db_connection() as conn:
+        # Songs table
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS songs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                artist TEXT NOT NULL,
+                album TEXT,
+                duration INTEGER,
+                bpm INTEGER,
+                energy_level INTEGER CHECK(energy_level BETWEEN 1 AND 10)
+            )
+        """)
+        
+        # Users table
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        
+        # Playlists table
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS playlists (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                vibe_code TEXT,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        
+        # Contexts table
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS contexts (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                weather TEXT,
+                time_of_day TEXT,
+                location_type TEXT
+            )
+        """)
+        
+        # Memories table
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS memories (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                description TEXT NOT NULL,
+                date TEXT,
+                song_id INTEGER,
+                FOREIGN KEY (user_id) REFERENCES users(id),
+                FOREIGN KEY (song_id) REFERENCES songs(id)
+            )
+        """)
+        
+        # Play history table (with composite primary key)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS play_history (
+                user_id INTEGER NOT NULL,
+                song_id INTEGER NOT NULL,
+                played_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                context_id INTEGER,
+                PRIMARY KEY (user_id, song_id, played_at),
+                FOREIGN KEY (user_id) REFERENCES users(id),
+                FOREIGN KEY (song_id) REFERENCES songs(id),
+                FOREIGN KEY (context_id) REFERENCES contexts(id)
+            )
+        """)
+        
+        conn.commit()
+
+
+# ============== SONGS ==============
+
+def add_song(title: str, artist: str, album: str = None, duration: int = None,
+             bpm: int = None, energy_level: int = None) -> dict:
+    """Add a new song."""
+    with get_db_connection() as conn:
+        cursor = conn.execute(
+            """INSERT INTO songs (title, artist, album, duration, bpm, energy_level) 
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (title, artist, album, duration, bpm, energy_level)
+        )
+        conn.commit()
+        song_id = cursor.lastrowid
+        return {"id": song_id, "title": title, "artist": artist, "album": album,
+                "duration": duration, "bpm": bpm, "energy_level": energy_level}
+
+
+def get_all_songs() -> list[dict]:
+    """Get all songs."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM songs")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_song_by_id(song_id: int) -> Optional[dict]:
+    """Get a song by ID."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM songs WHERE id = ?", (song_id,))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+
+
+def delete_song(song_id: int) -> bool:
+    """Delete a song."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("DELETE FROM songs WHERE id = ?", (song_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+# ============== USERS ==============
+
+def add_user(name: str) -> dict:
+    """Add a new user."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("INSERT INTO users (name) VALUES (?)", (name,))
+        conn.commit()
+        user_id = cursor.lastrowid
+        cursor = conn.execute("SELECT * FROM users WHERE id = ?", (user_id,))
+        return dict(cursor.fetchone())
+
+
+def get_all_users() -> list[dict]:
+    """Get all users."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM users")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_user_by_id(user_id: int) -> Optional[dict]:
+    """Get a user by ID."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM users WHERE id = ?", (user_id,))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+
+
+# ============== PLAYLISTS ==============
+
+def add_playlist(name: str, vibe_code: str = None) -> dict:
+    """Add a new playlist."""
+    with get_db_connection() as conn:
+        cursor = conn.execute(
+            "INSERT INTO playlists (name, vibe_code) VALUES (?, ?)",
+            (name, vibe_code)
+        )
+        conn.commit()
+        playlist_id = cursor.lastrowid
+        cursor = conn.execute("SELECT * FROM playlists WHERE id = ?", (playlist_id,))
+        return dict(cursor.fetchone())
+
+
+def get_all_playlists() -> list[dict]:
+    """Get all playlists."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM playlists")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def delete_playlist(playlist_id: int) -> bool:
+    """Delete a playlist."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("DELETE FROM playlists WHERE id = ?", (playlist_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+# ============== MEMORIES ==============
+
+def add_memory(user_id: int, description: str, date: str = None, song_id: int = None) -> dict:
+    """Add a new memory."""
+    with get_db_connection() as conn:
+        cursor = conn.execute(
+            "INSERT INTO memories (user_id, description, date, song_id) VALUES (?, ?, ?, ?)",
+            (user_id, description, date, song_id)
+        )
+        conn.commit()
+        memory_id = cursor.lastrowid
+        cursor = conn.execute("SELECT * FROM memories WHERE id = ?", (memory_id,))
+        return dict(cursor.fetchone())
+
+
+def get_all_memories() -> list[dict]:
+    """Get all memories."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM memories")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_memories_by_user(user_id: int) -> list[dict]:
+    """Get memories for a specific user."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM memories WHERE user_id = ?", (user_id,))
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def delete_memory(memory_id: int) -> bool:
+    """Delete a memory."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("DELETE FROM memories WHERE id = ?", (memory_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+# ============== CONTEXTS ==============
+
+def add_context(weather: str = None, time_of_day: str = None, location_type: str = None) -> dict:
+    """Add a new context."""
+    with get_db_connection() as conn:
+        cursor = conn.execute(
+            "INSERT INTO contexts (weather, time_of_day, location_type) VALUES (?, ?, ?)",
+            (weather, time_of_day, location_type)
+        )
+        conn.commit()
+        context_id = cursor.lastrowid
+        cursor = conn.execute("SELECT * FROM contexts WHERE id = ?", (context_id,))
+        return dict(cursor.fetchone())
+
+
+def get_all_contexts() -> list[dict]:
+    """Get all contexts."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("SELECT * FROM contexts")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def delete_context(context_id: int) -> bool:
+    """Delete a context."""
+    with get_db_connection() as conn:
+        cursor = conn.execute("DELETE FROM contexts WHERE id = ?", (context_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+# ============== PLAY HISTORY ==============
+
+def add_play_history(user_id: int, song_id: int, context_id: int = None) -> dict:
+    """Add a play history entry."""
+    played_at = datetime.utcnow().isoformat()
+    with get_db_connection() as conn:
+        conn.execute(
+            """INSERT INTO play_history (user_id, song_id, played_at, context_id) 
+               VALUES (?, ?, ?, ?)""",
+            (user_id, song_id, played_at, context_id)
+        )
+        conn.commit()
+        return {"user_id": user_id, "song_id": song_id, "played_at": played_at, "context_id": context_id}
+
+
+def get_play_history(user_id: int = None, limit: int = 50) -> list[dict]:
+    """Get play history, optionally filtered by user."""
+    with get_db_connection() as conn:
+        if user_id:
+            cursor = conn.execute(
+                """SELECT ph.*, s.title, s.artist 
+                   FROM play_history ph 
+                   JOIN songs s ON ph.song_id = s.id 
+                   WHERE ph.user_id = ?
+                   ORDER BY ph.played_at DESC LIMIT ?""",
+                (user_id, limit)
+            )
+        else:
+            cursor = conn.execute(
+                """SELECT ph.*, s.title, s.artist 
+                   FROM play_history ph 
+                   JOIN songs s ON ph.song_id = s.id 
+                   ORDER BY ph.played_at DESC LIMIT ?""",
+                (limit,)
+            )
+        return [dict(row) for row in cursor.fetchall()]

main.py

@@ -1,22 +1,42 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, Query, HTTPException
+from fastapi.responses import JSONResponse
 import gradio as gr
 from app import gradio_app
+from database import (
+    init_database,
+    # Songs
+    add_song, get_all_songs, get_song_by_id, delete_song,
+    # Users
+    add_user, get_all_users, get_user_by_id,
+    # Playlists
+    add_playlist, get_all_playlists, delete_playlist,
+    # Memories
+    add_memory, get_all_memories, get_memories_by_user, delete_memory,
+    # Contexts
+    add_context, get_all_contexts, delete_context,
+    # Play History
+    add_play_history, get_play_history,
+)
+from semantic_search import (
+    # Song vibes
+    add_song_vibe, search_song_vibes, remove_song_vibe,
+    # Memory vibes
+    add_memory_vibe, search_memory_vibes, remove_memory_vibe,
+    # Context vibes
+    add_context_vibe, search_context_vibes, remove_context_vibe,
+    # Playlist journeys
+    add_playlist_journey, search_playlist_journeys, remove_playlist_journey,
+)
 
 app = FastAPI()
 
-# Static product data
-PRODUCTS = [
-    {"id": 1, "name": "Laptop", "price": 999.99, "category": "Electronics"},
-    {"id": 2, "name": "Headphones", "price": 149.99, "category": "Electronics"},
-    {"id": 3, "name": "Coffee Mug", "price": 12.99, "category": "Home"},
-    {"id": 4, "name": "Notebook", "price": 5.99, "category": "Office"},
-    {"id": 5, "name": "Water Bottle", "price": 24.99, "category": "Home"},
-]
+# Initialize SQLite database on startup
+init_database()
 
 
 @app.get("/")
 def greet_json():
-    return {"Hello": "World!"}
+    return {"Hello": "World!", "app": "Music Memories"}
 
 
 @app.get("/health")
@@ -24,10 +44,200 @@ def health_check():
     return {"status": "healthy", "timestamp": "2026-03-30T00:00:00Z"}
 
 
-@app.get("/products")
-def get_products():
-    return {"products": PRODUCTS}
+# ============== SONGS ==============
+
+@app.get("/songs")
+def list_songs():
+    """Get all songs."""
+    return {"songs": get_all_songs()}
+
+
+@app.get("/songs/{song_id}")
+def get_song(song_id: int):
+    """Get a song by ID."""
+    song = get_song_by_id(song_id)
+    if not song:
+        raise HTTPException(status_code=404, detail="Song not found")
+    return song
+
+
+@app.post("/songs")
+def create_song(title: str, artist: str, album: str = None, duration: int = None,
+                bpm: int = None, energy_level: int = None, lyrics: str = None):
+    """Add a new song."""
+    song = add_song(title, artist, album, duration, bpm, energy_level)
+    # Add to semantic search index if lyrics provided
+    if lyrics:
+        add_song_vibe(song["id"], title, artist, lyrics)
+    return {"status": "success", "song": song}
+
+
+@app.delete("/songs/{song_id}")
+def delete_song_endpoint(song_id: int):
+    """Delete a song."""
+    if not delete_song(song_id):
+        raise HTTPException(status_code=404, detail="Song not found")
+    remove_song_vibe(song_id)
+    return {"status": "success", "deleted_id": song_id}
+
+
+# ============== USERS ==============
+
+@app.get("/users")
+def list_users():
+    """Get all users."""
+    return {"users": get_all_users()}
+
+
+@app.get("/users/{user_id}")
+def get_user(user_id: int):
+    """Get a user by ID."""
+    user = get_user_by_id(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+
+@app.post("/users")
+def create_user(name: str):
+    """Add a new user."""
+    user = add_user(name)
+    return {"status": "success", "user": user}
+
+
+# ============== PLAYLISTS ==============
+
+@app.get("/playlists")
+def list_playlists():
+    """Get all playlists."""
+    return {"playlists": get_all_playlists()}
+
+
+@app.post("/playlists")
+def create_playlist(name: str, vibe_code: str = None, mood_description: str = None):
+    """Add a new playlist."""
+    playlist = add_playlist(name, vibe_code)
+    # Add to playlist journeys for mood search
+    if mood_description:
+        add_playlist_journey(playlist["id"], name, mood_description)
+    return {"status": "success", "playlist": playlist}
+
+
+@app.delete("/playlists/{playlist_id}")
+def delete_playlist_endpoint(playlist_id: int):
+    """Delete a playlist."""
+    if not delete_playlist(playlist_id):
+        raise HTTPException(status_code=404, detail="Playlist not found")
+    remove_playlist_journey(playlist_id)
+    return {"status": "success", "deleted_id": playlist_id}
+
+
+# ============== MEMORIES ==============
+
+@app.get("/memories")
+def list_memories():
+    """Get all memories."""
+    return {"memories": get_all_memories()}
+
+
+@app.get("/users/{user_id}/memories")
+def list_user_memories(user_id: int):
+    """Get memories for a specific user."""
+    if not get_user_by_id(user_id):
+        raise HTTPException(status_code=404, detail="User not found")
+    return {"memories": get_memories_by_user(user_id)}
+
+
+@app.post("/memories")
+def create_memory(user_id: int, description: str, date: str = None, song_id: int = None):
+    """Add a new memory."""
+    if not get_user_by_id(user_id):
+        raise HTTPException(status_code=404, detail="User not found")
+    memory = add_memory(user_id, description, date, song_id)
+    # Add to semantic search index
+    add_memory_vibe(memory["id"], user_id, description)
+    return {"status": "success", "memory": memory}
+
+
+@app.delete("/memories/{memory_id}")
+def delete_memory_endpoint(memory_id: int):
+    """Delete a memory."""
+    if not delete_memory(memory_id):
+        raise HTTPException(status_code=404, detail="Memory not found")
+    remove_memory_vibe(memory_id)
+    return {"status": "success", "deleted_id": memory_id}
+
+
+# ============== CONTEXTS ==============
+
+@app.get("/contexts")
+def list_contexts():
+    """Get all contexts."""
+    return {"contexts": get_all_contexts()}
+
+
+@app.post("/contexts")
+def create_context(weather: str = None, time_of_day: str = None, location_type: str = None):
+    """Add a new context."""
+    context = add_context(weather, time_of_day, location_type)
+    # Add to semantic search index
+    add_context_vibe(context["id"], weather or "", time_of_day or "", location_type or "")
+    return {"status": "success", "context": context}
+
+
+@app.delete("/contexts/{context_id}")
+def delete_context_endpoint(context_id: int):
+    """Delete a context."""
+    if not delete_context(context_id):
+        raise HTTPException(status_code=404, detail="Context not found")
+    remove_context_vibe(context_id)
+    return {"status": "success", "deleted_id": context_id}
+
+
+# ============== PLAY HISTORY ==============
+
+@app.get("/history")
+def list_history(user_id: int = None, limit: int = 50):
+    """Get play history."""
+    return {"history": get_play_history(user_id, limit)}
+
+
+@app.post("/history")
+def create_history(user_id: int, song_id: int, context_id: int = None):
+    """Add a play history entry."""
+    history = add_play_history(user_id, song_id, context_id)
+    return {"status": "success", "history": history}
+
+
+# ============== SEMANTIC SEARCH ==============
+
+@app.get("/search/songs")
+def search_songs(q: str = Query(..., description="Search query"), n: int = Query(5, description="Number of results")):
+    """Semantic search for songs by vibe/lyrics."""
+    results = search_song_vibes(q, n_results=n)
+    return {"query": q, "results": results}
+
+
+@app.get("/search/memories")
+def search_memories(q: str = Query(..., description="Search query"), n: int = Query(5, description="Number of results")):
+    """Semantic search for memories."""
+    results = search_memory_vibes(q, n_results=n)
+    return {"query": q, "results": results}
+
+
+@app.get("/search/contexts")
+def search_contexts(q: str = Query(..., description="Search query"), n: int = Query(5, description="Number of results")):
+    """Semantic search for contexts."""
+    results = search_context_vibes(q, n_results=n)
+    return {"query": q, "results": results}
+
+
+@app.get("/search/playlists")
+def search_playlists(q: str = Query(..., description="Search query"), n: int = Query(5, description="Number of results")):
+    """Semantic search for playlists by mood."""
+    results = search_playlist_journeys(q, n_results=n)
+    return {"query": q, "results": results}
 
 
 # Mount the Gradio app at /ui
-app = gr.mount_gradio_app(app, gradio_app, path="/ui")
+app = gr.mount_gradio_app(app, gradio_app, path="/ui")

pyproject.toml

@@ -7,11 +7,13 @@ requires-python = ">=3.12"
 dependencies = [
    "accelerate>=1.13.0",
    "bitsandbytes>=0.49.2; sys_platform == 'linux' and platform_machine == 'x86_64'",
+   "chromadb>=0.5.0",
    "datasets>=4.8.4",
    "fastapi>=0.135.2",
    "gradio>=4.0.0",
    "huggingface-hub>=1.8.0",
    "peft>=0.18.1",
+   "sentence-transformers>=3.0.0",
    "torch>=2.5.0",
    "torchaudio>=2.5.0",
    "transformers>=5.4.0",

seed_data.json

@@ -0,0 +1,8 @@
+# Initial products for seeding the database
+[
+    {"name": "Laptop", "price": 999.99, "category": "Electronics"},
+    {"name": "Headphones", "price": 149.99, "category": "Electronics"},
+    {"name": "Coffee Mug", "price": 12.99, "category": "Home"},
+    {"name": "Notebook", "price": 5.99, "category": "Office"},
+    {"name": "Water Bottle", "price": 24.99, "category": "Home"}
+]

seed_db.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Seed the database with initial data for consistent Docker builds."""
+
+import json
+import os
+from database import (
+    init_database,
+    add_song, add_user, add_playlist, add_memory, add_context,
+    get_all_songs, get_all_users
+)
+from semantic_search import (
+    add_song_vibe, add_memory_vibe, add_context_vibe, add_playlist_journey
+)
+
+
+def seed_database():
+    """Initialize and seed the database with sample data."""
+    
+    # Initialize SQLite tables
+    print("📦 Initializing database...")
+    init_database()
+    
+    # Check if already seeded
+    if get_all_songs():
+        print("✅ Database already seeded, skipping...")
+        return
+    
+    print("🌱 Seeding database...")
+    
+    # ============== SONGS ==============
+    songs_data = [
+        {"title": "Bohemian Rhapsody", "artist": "Queen", "album": "A Night at the Opera", "duration": 354, "bpm": 72, "energy_level": 8, "lyrics": "Is this the real life? Is this just fantasy? Caught in a landslide, no escape from reality"},
+        {"title": "Imagine", "artist": "John Lennon", "album": "Imagine", "duration": 183, "bpm": 75, "energy_level": 3, "lyrics": "Imagine there's no heaven, it's easy if you try, no hell below us, above us only sky"},
+        {"title": "Blinding Lights", "artist": "The Weeknd", "album": "After Hours", "duration": 200, "bpm": 171, "energy_level": 9, "lyrics": "I've been on my own for long enough, maybe you can show me how to love, maybe"},
+        {"title": "Someone Like You", "artist": "Adele", "album": "21", "duration": 285, "bpm": 67, "energy_level": 4, "lyrics": "I heard that you're settled down, that you found a girl and you're married now"},
+        {"title": "Uptown Funk", "artist": "Mark Ronson ft. Bruno Mars", "album": "Uptown Special", "duration": 269, "bpm": 115, "energy_level": 10, "lyrics": "This hit, that ice cold, Michelle Pfeiffer, that white gold"},
+        {"title": "Fix You", "artist": "Coldplay", "album": "X&Y", "duration": 295, "bpm": 138, "energy_level": 5, "lyrics": "When you try your best but you don't succeed, when you get what you want but not what you need"},
+        {"title": "Lose Yourself", "artist": "Eminem", "album": "8 Mile", "duration": 326, "bpm": 86, "energy_level": 9, "lyrics": "Look, if you had one shot or one opportunity, to seize everything you ever wanted"},
+        {"title": "Let It Be", "artist": "The Beatles", "album": "Let It Be", "duration": 243, "bpm": 75, "energy_level": 3, "lyrics": "When I find myself in times of trouble, Mother Mary comes to me"},
+        {"title": "Rolling in the Deep", "artist": "Adele", "album": "21", "duration": 228, "bpm": 105, "energy_level": 7, "lyrics": "There's a fire starting in my heart, I'm reaching for every high and low"},
+        {"title": "Happy", "artist": "Pharrell Williams", "album": "G I R L", "duration": 232, "bpm": 160, "energy_level": 10, "lyrics": "It might seem crazy what I'm about to say, sunshine she's here, you can take a guess"},
+    ]
+    
+    print("🎵 Adding songs...")
+    for song in songs_data:
+        lyrics = song.pop("lyrics")
+        added_song = add_song(**song)
+        add_song_vibe(added_song["id"], song["title"], song["artist"], lyrics)
+    
+    # ============== USERS ==============
+    users_data = ["Alice", "Bob", "Charlie", "Diana", "Eve"]
+    
+    print("👤 Adding users...")
+    for name in users_data:
+        add_user(name)
+    
+    # ============== PLAYLISTS ==============
+    playlists_data = [
+        {"name": "Rainy Day Vibes", "vibe_code": "chill_melancholy", "mood": "Perfect for cloudy afternoons when you want to feel your feelings"},
+        {"name": "Workout Energy", "vibe_code": "high_energy", "mood": "Maximum pump-up tracks for crushing your fitness goals"},
+        {"name": "Late Night Coding", "vibe_code": "focus_calm", "mood": "Deep focus music for those 3am debugging sessions"},
+        {"name": "Road Trip Classics", "vibe_code": "adventure_fun", "mood": "Windows down, volume up, endless highway ahead"},
+        {"name": "Heartbreak Recovery", "vibe_code": "sad_to_healing", "mood": "Journey from tears to acceptance, one song at a time"},
+    ]
+    
+    print("🎵 Adding playlists...")
+    for pl in playlists_data:
+        mood = pl.pop("mood")
+        added_pl = add_playlist(**pl)
+        add_playlist_journey(added_pl["id"], pl["name"], mood)
+    
+    # ============== CONTEXTS ==============
+    contexts_data = [
+        {"weather": "rainy", "time_of_day": "night", "location_type": "home"},
+        {"weather": "sunny", "time_of_day": "morning", "location_type": "car"},
+        {"weather": "cloudy", "time_of_day": "afternoon", "location_type": "office"},
+        {"weather": "clear", "time_of_day": "evening", "location_type": "gym"},
+        {"weather": "stormy", "time_of_day": "night", "location_type": "home"},
+    ]
+    
+    print("🌤️ Adding contexts...")
+    for ctx in contexts_data:
+        added_ctx = add_context(**ctx)
+        add_context_vibe(added_ctx["id"], ctx.get("weather", ""), ctx.get("time_of_day", ""), ctx.get("location_type", ""))
+    
+    # ============== MEMORIES ==============
+    memories_data = [
+        {"user_id": 1, "description": "First dance at my wedding, perfect song for the perfect moment", "date": "2024-06-15"},
+        {"user_id": 1, "description": "Road trip to the coast with friends, singing at the top of our lungs", "date": "2024-07-20"},
+        {"user_id": 2, "description": "Studying for finals, this song kept me going through the night", "date": "2024-03-10"},
+        {"user_id": 2, "description": "Running my first 5K, this was my power song at the finish line", "date": "2024-05-01"},
+        {"user_id": 3, "description": "Grandma's funeral, this song made everyone cry but also smile", "date": "2023-11-30"},
+    ]
+    
+    print("💭 Adding memories...")
+    for mem in memories_data:
+        added_mem = add_memory(**mem)
+        add_memory_vibe(added_mem["id"], mem["user_id"], mem["description"])
+    
+    print("\n✅ Database seeded successfully!")
+    print(f"   - {len(songs_data)} songs")
+    print(f"   - {len(users_data)} users")
+    print(f"   - {len(playlists_data)} playlists")
+    print(f"   - {len(contexts_data)} contexts")
+    print(f"   - {len(memories_data)} memories")
+
+
+if __name__ == "__main__":
+    seed_database()

semantic_search.py

@@ -0,0 +1,147 @@
+"""ChromaDB semantic search module for music memories app."""
+
+import chromadb
+from sentence_transformers import SentenceTransformer
+
+# Initialize the embedding model
+embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+# Initialize ChromaDB client with persistent storage
+chroma_client = chromadb.PersistentClient(path="./chroma_db")
+
+# Create collections for different semantic search types
+song_vibes_collection = chroma_client.get_or_create_collection(name="song_vibes")
+memory_vibes_collection = chroma_client.get_or_create_collection(name="memory_vibes")
+context_vibes_collection = chroma_client.get_or_create_collection(name="context_vibes")
+playlist_journeys_collection = chroma_client.get_or_create_collection(name="playlist_journeys")
+
+
+# ============== SONG VIBES ==============
+
+def add_song_vibe(song_id: int, title: str, artist: str, lyrics: str = "") -> None:
+    """Add song embedding based on lyrics/title/artist."""
+    text = f"{title} by {artist} - {lyrics}".strip()
+    song_vibes_collection.add(
+        ids=[f"song_{song_id}"],
+        documents=[text],
+        metadatas=[{"id": song_id, "title": title, "artist": artist}],
+    )
+
+
+def search_song_vibes(query: str, n_results: int = 5) -> list[dict]:
+    """Search songs by vibe/lyrics."""
+    results = song_vibes_collection.query(
+        query_texts=[query],
+        n_results=n_results,
+        include=["documents", "metadatas", "distances"],
+    )
+    if not results["metadatas"] or not results["metadatas"][0]:
+        return []
+    return [
+        {"id": m["id"], "title": m["title"], "artist": m["artist"],
+         "document": results["documents"][0][i], "distance": results["distances"][0][i]}
+        for i, m in enumerate(results["metadatas"][0])
+    ]
+
+
+def remove_song_vibe(song_id: int) -> None:
+    """Remove a song vibe."""
+    song_vibes_collection.delete(ids=[f"song_{song_id}"])
+
+
+# ============== MEMORY VIBES ==============
+
+def add_memory_vibe(memory_id: int, user_id: int, description: str) -> None:
+    """Add memory embedding based on description."""
+    memory_vibes_collection.add(
+        ids=[f"memory_{memory_id}"],
+        documents=[description],
+        metadatas=[{"id": memory_id, "user_id": user_id}],
+    )
+
+
+def search_memory_vibes(query: str, n_results: int = 5) -> list[dict]:
+    """Search memories by description."""
+    results = memory_vibes_collection.query(
+        query_texts=[query],
+        n_results=n_results,
+        include=["documents", "metadatas", "distances"],
+    )
+    if not results["metadatas"] or not results["metadatas"][0]:
+        return []
+    return [
+        {"id": m["id"], "user_id": m["user_id"],
+         "document": results["documents"][0][i], "distance": results["distances"][0][i]}
+        for i, m in enumerate(results["metadatas"][0])
+    ]
+
+
+def remove_memory_vibe(memory_id: int) -> None:
+    """Remove a memory vibe."""
+    memory_vibes_collection.delete(ids=[f"memory_{memory_id}"])
+
+
+# ============== CONTEXT VIBES ==============
+
+def add_context_vibe(context_id: int, weather: str, time_of_day: str, location_type: str) -> None:
+    """Add context embedding."""
+    text = f"Weather: {weather}, Time: {time_of_day}, Location: {location_type}".strip()
+    context_vibes_collection.add(
+        ids=[f"context_{context_id}"],
+        documents=[text],
+        metadatas=[{"id": context_id, "weather": weather, "time_of_day": time_of_day, "location_type": location_type}],
+    )
+
+
+def search_context_vibes(query: str, n_results: int = 5) -> list[dict]:
+    """Search contexts by description."""
+    results = context_vibes_collection.query(
+        query_texts=[query],
+        n_results=n_results,
+        include=["documents", "metadatas", "distances"],
+    )
+    if not results["metadatas"] or not results["metadatas"][0]:
+        return []
+    return [
+        {"id": m["id"], "weather": m["weather"], "time_of_day": m["time_of_day"],
+         "location_type": m["location_type"], "document": results["documents"][0][i],
+         "distance": results["distances"][0][i]}
+        for i, m in enumerate(results["metadatas"][0])
+    ]
+
+
+def remove_context_vibe(context_id: int) -> None:
+    """Remove a context vibe."""
+    context_vibes_collection.delete(ids=[f"context_{context_id}"])
+
+
+# ============== PLAYLIST JOURNEYS ==============
+
+def add_playlist_journey(playlist_id: int, name: str, mood_description: str) -> None:
+    """Add playlist journey embedding for mood transitions."""
+    playlist_journeys_collection.add(
+        ids=[f"playlist_{playlist_id}"],
+        documents=[f"{name}: {mood_description}"],
+        metadatas=[{"id": playlist_id, "name": name}],
+    )
+
+
+def search_playlist_journeys(query: str, n_results: int = 5) -> list[dict]:
+    """Search playlists by mood/vibe."""
+    results = playlist_journeys_collection.query(
+        query_texts=[query],
+        n_results=n_results,
+        include=["documents", "metadatas", "distances"],
+    )
+    if not results["metadatas"] or not results["metadatas"][0]:
+        return []
+    return [
+        {"id": m["id"], "name": m["name"],
+         "document": results["documents"][0][i], "distance": results["distances"][0][i]}
+        for i, m in enumerate(results["metadatas"][0])
+    ]
+
+
+def remove_playlist_journey(playlist_id: int) -> None:
+    """Remove a playlist journey."""
+    playlist_journeys_collection.delete(ids=[f"playlist_{playlist_id}"])