redis is here

.qwen/settings.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(curl *)",
+      "Bash(python3 *)",
+      "Bash(sleep *)"
+    ]
+  },
+  "$version": 3
+}

.qwen/settings.json.orig

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(curl *)"
+    ]
+  }
+}

Dockerfile

@@ -1,8 +1,11 @@
-# Hugging Face Spaces (Docker SDK) - FastAPI + Uvicorn using uv
+# Hugging Face Spaces (Docker SDK) - FastAPI + Uvicorn + Redis
 # Docs: https://huggingface.co/docs/hub/spaces-sdks-docker
 
 FROM python:3.12-slim
 
+# Install Redis
+RUN apt-get update && apt-get install -y redis-server && rm -rf /var/lib/apt/lists/*
+
 # Create a non-root user matching HF Spaces expectations
 RUN useradd -m -u 1000 user
 USER user
@@ -11,6 +14,10 @@ USER user
 ENV PATH="/home/user/.local/bin:/app/.venv/bin:$PATH"
 ENV CHROMA_DB_HOST_IP="127.0.0.1"
 ENV ANONYMIZED_TELEMETRY="false"
+ENV REDIS_HOST="127.0.0.1"
+ENV REDIS_PORT="6379"
+ENV REDIS_DB="0"
+ENV CACHE_TTL="300"
 WORKDIR /app
 
 # Install uv (dependency manager)
@@ -27,11 +34,12 @@ RUN uv venv /app/.venv \
 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
+RUN mkdir -p /app/chroma_db /app/data /app/redis_data && chown -R user:user /app/chroma_db /app/data /app/redis_data
 
 # Seed the database (consistent data in every container)
 RUN uv run python seed_db.py
 
-EXPOSE 7860
+EXPOSE 7860 6379
 
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Start Redis and the app
+CMD ["sh", "-c", "redis-server --daemonize yes --dir /app/redis_data --appendonly yes && uvicorn main:app --host 0.0.0.0 --port 7860"]

main.py

@@ -1,3 +1,4 @@
+from contextlib import asynccontextmanager
 from fastapi import FastAPI, Query, HTTPException
 from fastapi.responses import JSONResponse
 import gradio as gr
@@ -27,11 +28,32 @@ from semantic_search import (
     # Playlist journeys
     add_playlist_journey, search_playlist_journeys, remove_playlist_journey,
 )
+from redis_client import (
+    init_redis,
+    close_redis,
+    get_cached_song, cache_song, invalidate_song_cache,
+    get_cached_user, cache_user, invalidate_user_cache,
+    get_cached_playlist, cache_playlist, invalidate_playlist_cache,
+    get_cached_list, cache_list, invalidate_list_cache, cache_delete_pattern,
+    store_play_event, get_user_play_history, get_global_play_history,
+)
+import asyncio
 
 app = FastAPI()
 
-# Initialize SQLite database on startup
-init_database()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager for Redis and database initialization."""
+    # Startup
+    init_database()
+    await init_redis()
+    yield
+    # Shutdown
+    await close_redis()
+
+
+app.router.lifespan_context = lifespan
 
 
 @app.get("/")
@@ -40,173 +62,282 @@ def greet_json():
 
 
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "timestamp": "2026-03-30T00:00:00Z"}
+async def health_check():
+    """Health check endpoint with Redis status."""
+    from redis_client import get_redis_client
+    redis_status = "disconnected"
+    try:
+        redis_client = get_redis_client()
+        if redis_client:
+            await redis_client.ping()
+            redis_status = "connected"
+    except Exception:
+        redis_status = "error"
+    
+    return {
+        "status": "healthy",
+        "redis": redis_status,
+        "database": "sqlite"
+    }
 
 
 # ============== SONGS ==============
 
 @app.get("/songs")
-def list_songs():
+async def list_songs():
     """Get all songs."""
-    return {"songs": get_all_songs()}
+    # Try cache first
+    cached = await get_cached_list("all_songs")
+    if cached:
+        return {"songs": cached, "source": "cache"}
+    
+    # Fetch from database
+    songs = get_all_songs()
+    await cache_list("all_songs", songs)
+    return {"songs": songs, "source": "database"}
 
 
 @app.get("/songs/{song_id}")
-def get_song(song_id: int):
+async def get_song(song_id: int):
     """Get a song by ID."""
+    # Try cache first
+    song = await get_cached_song(song_id)
+    if song:
+        return {**song, "source": "cache"}
+    
+    # Fetch from database
     song = get_song_by_id(song_id)
     if not song:
         raise HTTPException(status_code=404, detail="Song not found")
-    return song
+    
+    await cache_song(song_id, song)
+    return {**song, "source": "database"}
 
 
 @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):
+async 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)
+    # Invalidate songs list cache
+    await invalidate_list_cache("all_songs")
     return {"status": "success", "song": song}
 
 
 @app.delete("/songs/{song_id}")
-def delete_song_endpoint(song_id: int):
+async 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)
+    await invalidate_song_cache(song_id)
+    await invalidate_list_cache("all_songs")
     return {"status": "success", "deleted_id": song_id}
 
 
 # ============== USERS ==============
 
 @app.get("/users")
-def list_users():
+async def list_users():
     """Get all users."""
-    return {"users": get_all_users()}
+    # Try cache first
+    cached = await get_cached_list("all_users")
+    if cached:
+        return {"users": cached, "source": "cache"}
+    
+    # Fetch from database
+    users = get_all_users()
+    await cache_list("all_users", users)
+    return {"users": users, "source": "database"}
 
 
 @app.get("/users/{user_id}")
-def get_user(user_id: int):
+async def get_user(user_id: int):
     """Get a user by ID."""
+    # Try cache first
+    user = await get_cached_user(user_id)
+    if user:
+        return {**user, "source": "cache"}
+    
+    # Fetch from database
     user = get_user_by_id(user_id)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
-    return user
+    
+    await cache_user(user_id, user)
+    return {**user, "source": "database"}
 
 
 @app.post("/users")
-def create_user(name: str):
+async def create_user(name: str):
     """Add a new user."""
     user = add_user(name)
+    await invalidate_list_cache("all_users")
     return {"status": "success", "user": user}
 
 
 # ============== PLAYLISTS ==============
 
 @app.get("/playlists")
-def list_playlists():
+async def list_playlists():
     """Get all playlists."""
-    return {"playlists": get_all_playlists()}
+    # Try cache first
+    cached = await get_cached_list("all_playlists")
+    if cached:
+        return {"playlists": cached, "source": "cache"}
+    
+    # Fetch from database
+    playlists = get_all_playlists()
+    await cache_list("all_playlists", playlists)
+    return {"playlists": playlists, "source": "database"}
 
 
 @app.post("/playlists")
-def create_playlist(name: str, vibe_code: str = None, mood_description: str = None):
+async 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)
+    await invalidate_list_cache("all_playlists")
     return {"status": "success", "playlist": playlist}
 
 
 @app.delete("/playlists/{playlist_id}")
-def delete_playlist_endpoint(playlist_id: int):
+async 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)
+    await invalidate_playlist_cache(playlist_id)
+    await invalidate_list_cache("all_playlists")
     return {"status": "success", "deleted_id": playlist_id}
 
 
 # ============== MEMORIES ==============
 
 @app.get("/memories")
-def list_memories():
+async def list_memories():
     """Get all memories."""
-    return {"memories": get_all_memories()}
+    # Try cache first
+    cached = await get_cached_list("all_memories")
+    if cached:
+        return {"memories": cached, "source": "cache"}
+    
+    # Fetch from database
+    memories = get_all_memories()
+    await cache_list("all_memories", memories)
+    return {"memories": memories, "source": "database"}
 
 
 @app.get("/users/{user_id}/memories")
-def list_user_memories(user_id: int):
+async 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)}
+    
+    # Try cache first
+    cached = await get_cached_list(f"user_memories:{user_id}")
+    if cached:
+        return {"memories": cached, "source": "cache"}
+    
+    # Fetch from database
+    memories = get_memories_by_user(user_id)
+    await cache_list(f"user_memories:{user_id}", memories)
+    return {"memories": memories, "source": "database"}
 
 
 @app.post("/memories")
-def create_memory(user_id: int, description: str, date: str = None, song_id: int = None):
+async 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)
+    await invalidate_list_cache("all_memories")
+    await invalidate_list_cache(f"user_memories:{user_id}")
     return {"status": "success", "memory": memory}
 
 
 @app.delete("/memories/{memory_id}")
-def delete_memory_endpoint(memory_id: int):
+async 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)
+    await cache_delete_pattern("list:user_memories:*")
+    await invalidate_list_cache("all_memories")
     return {"status": "success", "deleted_id": memory_id}
 
 
 # ============== CONTEXTS ==============
 
 @app.get("/contexts")
-def list_contexts():
+async def list_contexts():
     """Get all contexts."""
-    return {"contexts": get_all_contexts()}
+    # Try cache first
+    cached = await get_cached_list("all_contexts")
+    if cached:
+        return {"contexts": cached, "source": "cache"}
+    
+    # Fetch from database
+    contexts = get_all_contexts()
+    await cache_list("all_contexts", contexts)
+    return {"contexts": contexts, "source": "database"}
 
 
 @app.post("/contexts")
-def create_context(weather: str = None, time_of_day: str = None, location_type: str = None):
+async 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 "")
+    await invalidate_list_cache("all_contexts")
     return {"status": "success", "context": context}
 
 
 @app.delete("/contexts/{context_id}")
-def delete_context_endpoint(context_id: int):
+async 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)
+    await invalidate_list_cache("all_contexts")
     return {"status": "success", "deleted_id": context_id}
 
 
 # ============== PLAY HISTORY ==============
 
 @app.get("/history")
-def list_history(user_id: int = None, limit: int = 50):
+async def list_history(user_id: int = None, limit: int = 50):
     """Get play history."""
-    return {"history": get_play_history(user_id, limit)}
+    if user_id:
+        # Try Redis first (hot storage)
+        history = await get_user_play_history(user_id, limit)
+        if not history:
+            # Fallback to SQLite
+            history = get_play_history(user_id, limit)
+        return {"history": history, "source": "redis" if history else "database"}
+    else:
+        # Try Redis first (hot storage)
+        history = await get_global_play_history(limit)
+        if not history:
+            # Fallback to SQLite
+            history = get_play_history(None, limit)
+        return {"history": history, "source": "redis" if history else "database"}
 
 
 @app.post("/history")
-def create_history(user_id: int, song_id: int, context_id: int = None):
+async 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}
+    # Store in Redis (fast write) and SQLite (persistent)
+    redis_event = await store_play_event(user_id, song_id, context_id)
+    sqlite_history = add_play_history(user_id, song_id, context_id)
+    return {"status": "success", "history": sqlite_history, "redis_stored": True}
 
 
 # ============== SEMANTIC SEARCH ==============

pyproject.toml

@@ -13,6 +13,7 @@ dependencies = [
    "gradio>=4.0.0",
    "huggingface-hub>=1.8.0",
    "peft>=0.18.1",
+   "redis>=5.0.0",
    "sentence-transformers>=3.0.0",
    "torch>=2.5.0",
    "torchaudio>=2.5.0",

redis_client.py

@@ -0,0 +1,275 @@
+"""Redis client module for caching and storage."""
+
+import json
+import os
+from typing import Optional, Any
+import redis.asyncio as redis
+from functools import wraps
+import hashlib
+
+
+# Redis configuration from environment variables
+REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
+REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))
+REDIS_DB = int(os.getenv("REDIS_DB", 0))
+REDIS_PASSWORD = os.getenv("REDIS_PASSWORD", None)
+CACHE_TTL = int(os.getenv("CACHE_TTL", 300))  # Default 5 minutes
+
+# Global Redis client instance
+_redis_client: Optional[redis.Redis] = None
+
+
+def get_redis_client() -> redis.Redis:
+    """Get or create the Redis client instance."""
+    global _redis_client
+    if _redis_client is None:
+        _redis_client = redis.Redis(
+            host=REDIS_HOST,
+            port=REDIS_PORT,
+            db=REDIS_DB,
+            password=REDIS_PASSWORD,
+            decode_responses=True,
+        )
+    return _redis_client
+
+
+async def init_redis() -> None:
+    """Initialize Redis connection."""
+    global _redis_client
+    _redis_client = redis.Redis(
+        host=REDIS_HOST,
+        port=REDIS_PORT,
+        db=REDIS_DB,
+        password=REDIS_PASSWORD,
+        decode_responses=True,
+    )
+    try:
+        await _redis_client.ping()
+        print(f"✓ Connected to Redis at {REDIS_HOST}:{REDIS_PORT}")
+    except redis.ConnectionError as e:
+        print(f"⚠ Redis connection failed: {e}")
+        print("⚠ Running without Redis caching")
+
+
+async def close_redis() -> None:
+    """Close Redis connection."""
+    global _redis_client
+    if _redis_client:
+        await _redis_client.close()
+        _redis_client = None
+
+
+def _generate_cache_key(prefix: str, *args, **kwargs) -> str:
+    """Generate a cache key from arguments."""
+    key_parts = [prefix]
+    for arg in args:
+        key_parts.append(str(arg))
+    for k, v in sorted(kwargs.items()):
+        key_parts.append(f"{k}={v}")
+    key_string = ":".join(key_parts)
+    return f"cache:{hashlib.md5(key_string.encode()).hexdigest()}"
+
+
+def cache_it(prefix: str, ttl: int = CACHE_TTL):
+    """Decorator to cache function results in Redis.
+    
+    Args:
+        prefix: Key prefix for the cache
+        ttl: Time to live in seconds
+    """
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            client = get_redis_client()
+            cache_key = _generate_cache_key(prefix, *args, **kwargs)
+            
+            # Try to get from cache
+            try:
+                cached = await client.get(cache_key)
+                if cached:
+                    return json.loads(cached)
+            except Exception:
+                pass  # Cache miss or error, proceed to fetch
+            
+            # Fetch fresh data
+            result = func(*args, **kwargs)
+            
+            # Store in cache
+            try:
+                await client.setex(cache_key, ttl, json.dumps(result))
+            except Exception:
+                pass  # Cache write failed, but return the result anyway
+            
+            return result
+        return wrapper
+    return decorator
+
+
+# ============== Cache helper functions ==============
+
+async def cache_get(key: str) -> Optional[Any]:
+    """Get a value from cache."""
+    try:
+        client = get_redis_client()
+        value = await client.get(key)
+        return json.loads(value) if value else None
+    except Exception:
+        return None
+
+
+async def cache_set(key: str, value: Any, ttl: int = CACHE_TTL) -> bool:
+    """Set a value in cache."""
+    try:
+        client = get_redis_client()
+        await client.setex(key, ttl, json.dumps(value))
+        return True
+    except Exception:
+        return False
+
+
+async def cache_delete(key: str) -> bool:
+    """Delete a key from cache."""
+    try:
+        client = get_redis_client()
+        await client.delete(key)
+        return True
+    except Exception:
+        return False
+
+
+async def cache_delete_pattern(pattern: str) -> bool:
+    """Delete keys matching a pattern."""
+    try:
+        client = get_redis_client()
+        keys = []
+        async for key in client.scan_iter(match=pattern):
+            keys.append(key)
+        if keys:
+            await client.delete(*keys)
+        return True
+    except Exception:
+        return False
+
+
+# ============== Entity-specific cache functions ==============
+
+# Songs cache
+async def cache_song(song_id: int, song_data: dict) -> bool:
+    """Cache a song by ID."""
+    return await cache_set(f"song:{song_id}", song_data)
+
+
+async def get_cached_song(song_id: int) -> Optional[dict]:
+    """Get a cached song by ID."""
+    return await cache_get(f"song:{song_id}")
+
+
+async def invalidate_song_cache(song_id: int) -> None:
+    """Invalidate song cache."""
+    await cache_delete(f"song:{song_id}")
+
+
+# Users cache
+async def cache_user(user_id: int, user_data: dict) -> bool:
+    """Cache a user by ID."""
+    return await cache_set(f"user:{user_id}", user_data)
+
+
+async def get_cached_user(user_id: int) -> Optional[dict]:
+    """Get a cached user by ID."""
+    return await cache_get(f"user:{user_id}")
+
+
+async def invalidate_user_cache(user_id: int) -> None:
+    """Invalidate user cache."""
+    await cache_delete(f"user:{user_id}")
+
+
+# Playlists cache
+async def cache_playlist(playlist_id: int, playlist_data: dict) -> bool:
+    """Cache a playlist by ID."""
+    return await cache_set(f"playlist:{playlist_id}", playlist_data)
+
+
+async def get_cached_playlist(playlist_id: int) -> Optional[dict]:
+    """Get a cached playlist by ID."""
+    return await cache_get(f"playlist:{playlist_id}")
+
+
+async def invalidate_playlist_cache(playlist_id: int) -> None:
+    """Invalidate playlist cache."""
+    await cache_delete(f"playlist:{playlist_id}")
+
+
+# Lists cache (for collections)
+async def cache_list(key: str, data: list) -> bool:
+    """Cache a list of items."""
+    return await cache_set(f"list:{key}", data, ttl=60)  # Shorter TTL for lists
+
+
+async def get_cached_list(key: str) -> Optional[list]:
+    """Get a cached list."""
+    return await cache_get(f"list:{key}")
+
+
+async def invalidate_list_cache(key: str) -> None:
+    """Invalidate a list cache."""
+    await cache_delete(f"list:{key}")
+
+
+# ============== Play History in Redis (hot storage) ==============
+
+async def store_play_event(user_id: int, song_id: int, context_id: Optional[int] = None) -> dict:
+    """Store a play event in Redis (fast write)."""
+    from datetime import datetime
+    played_at = datetime.utcnow().isoformat()
+    event = {
+        "user_id": user_id,
+        "song_id": song_id,
+        "context_id": context_id,
+        "played_at": played_at
+    }
+    
+    try:
+        client = get_redis_client()
+        # Add to sorted set for this user (score = timestamp)
+        await client.zadd(
+            f"play_history:user:{user_id}",
+            {json.dumps(event): datetime.utcnow().timestamp()}
+        )
+        # Also add to global history
+        await client.zadd(
+            "play_history:global",
+            {json.dumps(event): datetime.utcnow().timestamp()}
+        )
+    except Exception:
+        pass  # Best effort, SQLite is the source of truth
+    
+    return event
+
+
+async def get_user_play_history(user_id: int, limit: int = 50) -> list[dict]:
+    """Get play history for a user from Redis."""
+    try:
+        client = get_redis_client()
+        # Get latest entries from sorted set
+        events = await client.zrevrange(
+            f"play_history:user:{user_id}",
+            0, limit - 1
+        )
+        return [json.loads(e) for e in events]
+    except Exception:
+        return []
+
+
+async def get_global_play_history(limit: int = 50) -> list[dict]:
+    """Get global play history from Redis."""
+    try:
+        client = get_redis_client()
+        events = await client.zrevrange(
+            "play_history:global",
+            0, limit - 1
+        )
+        return [json.loads(e) for e in events]
+    except Exception:
+        return []