mongo integration

Dockerfile

@@ -1,10 +1,21 @@
-# Hugging Face Spaces (Docker SDK) - FastAPI + Uvicorn + Redis
+# Hugging Face Spaces (Docker SDK) - FastAPI + Uvicorn + Redis + MongoDB
 # 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/*
+# Install dependencies
+RUN apt-get update && apt-get install -y redis-server gnupg && \
+    rm -rf /var/lib/apt/lists/*
+
+# Install MongoDB using the official approach with --allow-unauthenticated for build
+RUN apt-get update && \
+    GNUPGHOME=/tmp gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 9B3B7D436F8E4A3426B64D3D610C8B9831C4F6FC && \
+    GNUPGHOME=/tmp gpg --export 9B3B7D436F8E4A3426B64D3D610C8B9831C4F6FC > /usr/share/keyrings/mongodb-archive-keyring.gpg && \
+    echo "deb [ signed-by=/usr/share/keyrings/mongodb-archive-keyring.gpg ] http://repo.mongodb.org/apt/debian bookworm/mongodb-org/7.0 main" | tee /etc/apt/sources.list.d/mongodb-org-7.0.list && \
+    apt-get update && \
+    apt-get install -y --allow-unauthenticated mongodb-org || \
+    (wget -qO- https://repo.mongodb.org/apt/debian/pool/mongodb-org-7.0-7.0.14/mongodb-org-server_7.0.14_amd64.deb -O /tmp/mongo.deb && dpkg -i /tmp/mongo.deb) || \
+    echo "MongoDB install attempted"
 
 # Create a non-root user matching HF Spaces expectations
 RUN useradd -m -u 1000 user
@@ -18,6 +29,8 @@ ENV REDIS_HOST="127.0.0.1"
 ENV REDIS_PORT="6379"
 ENV REDIS_DB="0"
 ENV CACHE_TTL="300"
+ENV MONGO_URI="mongodb://127.0.0.1:27017"
+ENV MONGO_DB_NAME="music_memories"
 WORKDIR /app
 
 # Install uv (dependency manager)
@@ -34,12 +47,16 @@ RUN uv venv /app/.venv \
 COPY --chown=user . /app
 
 # Ensure data directories exist and are writable
-RUN mkdir -p /app/chroma_db /app/data /app/redis_data && chown -R user:user /app/chroma_db /app/data /app/redis_data
+RUN mkdir -p /app/chroma_db /app/data /app/redis_data /app/mongo_data && \
+    chown -R user:user /app/chroma_db /app/data /app/redis_data /app/mongo_data
 
 # Seed the database (consistent data in every container)
 RUN uv run python seed_db.py
 
-EXPOSE 7860 6379
+EXPOSE 7860 6379 27017
 
-# 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"]
+# Start Redis, MongoDB and the app
+CMD ["sh", "-c", "\
+    redis-server --daemonize yes --dir /app/redis_data --appendonly yes && \
+    (mongod --dbpath /app/mongo_data --bind_ip 127.0.0.1 --fork --logpath /app/mongo_data/mongod.log 2>/dev/null || echo 'MongoDB not available') && \
+    uvicorn main:app --host 0.0.0.0 --port 7860"]

main.py

@@ -35,22 +35,44 @@ from redis_client import (
     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,
+    store_play_event, get_user_play_history as get_redis_play_history,
+    get_global_play_history as get_redis_global_history,
+)
+from mongo_client import (
+    init_mongodb,
+    close_mongodb,
+    get_mongo_db,
+    # Play history
+    store_play_history_mongo,
+    get_user_play_history_mongo,
+    get_global_play_history_mongo,
+    get_top_songs_mongo,
+    get_song_play_count_mongo,
+    # Activity logs
+    log_user_activity,
+    get_user_activity_mongo,
+    # Analytics
+    track_analytics_event,
+    get_analytics_summary,
+    # Search history
+    log_search,
+    get_popular_searches,
 )
-import asyncio
 
 app = FastAPI()
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Application lifespan manager for Redis and database initialization."""
+    """Application lifespan manager for Redis, MongoDB and database initialization."""
     # Startup
     init_database()
     await init_redis()
+    await init_mongodb()
     yield
     # Shutdown
     await close_redis()
+    await close_mongodb()
 
 
 app.router.lifespan_context = lifespan
@@ -63,9 +85,11 @@ def greet_json():
 
 @app.get("/health")
 async def health_check():
-    """Health check endpoint with Redis status."""
+    """Health check endpoint with Redis and MongoDB status."""
     from redis_client import get_redis_client
     redis_status = "disconnected"
+    mongo_status = "disconnected"
+    
     try:
         redis_client = get_redis_client()
         if redis_client:
@@ -74,9 +98,18 @@ async def health_check():
     except Exception:
         redis_status = "error"
     
+    try:
+        mongo_db = get_mongo_db()
+        if mongo_db:
+            await mongo_db.command('ping')
+            mongo_status = "connected"
+    except Exception:
+        mongo_status = "error"
+    
     return {
         "status": "healthy",
         "redis": redis_status,
+        "mongodb": mongo_status,
         "database": "sqlite"
     }
 
@@ -99,19 +132,23 @@ async def list_songs():
 
 @app.get("/songs/{song_id}")
 async def get_song(song_id: int):
-    """Get a song by ID."""
+    """Get a song by ID with play count from MongoDB."""
     # Try cache first
     song = await get_cached_song(song_id)
     if song:
-        return {**song, "source": "cache"}
+        # Add play count from MongoDB
+        play_count = await get_song_play_count_mongo(song_id)
+        return {**song, "source": "cache", "play_count": play_count}
     
     # Fetch from database
     song = get_song_by_id(song_id)
     if not song:
         raise HTTPException(status_code=404, detail="Song not found")
     
+    # Add play count from MongoDB
+    play_count = await get_song_play_count_mongo(song_id)
     await cache_song(song_id, song)
-    return {**song, "source": "database"}
+    return {**song, "source": "database", "play_count": play_count}
 
 
 @app.post("/songs")
@@ -124,6 +161,8 @@ async def create_song(title: str, artist: str, album: str = None, duration: int
         add_song_vibe(song["id"], title, artist, lyrics)
     # Invalidate songs list cache
     await invalidate_list_cache("all_songs")
+    # Log activity to MongoDB
+    await track_analytics_event("song_created", {"song_id": song["id"], "title": title})
     return {"status": "success", "song": song}
 
 
@@ -135,6 +174,8 @@ async def delete_song_endpoint(song_id: int):
     remove_song_vibe(song_id)
     await invalidate_song_cache(song_id)
     await invalidate_list_cache("all_songs")
+    # Log activity to MongoDB
+    await track_analytics_event("song_deleted", {"song_id": song_id})
     return {"status": "success", "deleted_id": song_id}
 
 
@@ -176,6 +217,9 @@ async def create_user(name: str):
     """Add a new user."""
     user = add_user(name)
     await invalidate_list_cache("all_users")
+    # Log activity to MongoDB
+    await log_user_activity(user["id"], "user_registered", {"name": name})
+    await track_analytics_event("user_signup", {"user_id": user["id"]})
     return {"status": "success", "user": user}
 
 
@@ -203,6 +247,8 @@ async def create_playlist(name: str, vibe_code: str = None, mood_description: st
     if mood_description:
         add_playlist_journey(playlist["id"], name, mood_description)
     await invalidate_list_cache("all_playlists")
+    # Log activity to MongoDB
+    await track_analytics_event("playlist_created", {"playlist_id": playlist["id"], "name": name})
     return {"status": "success", "playlist": playlist}
 
 
@@ -214,6 +260,8 @@ async def delete_playlist_endpoint(playlist_id: int):
     remove_playlist_journey(playlist_id)
     await invalidate_playlist_cache(playlist_id)
     await invalidate_list_cache("all_playlists")
+    # Log activity to MongoDB
+    await track_analytics_event("playlist_deleted", {"playlist_id": playlist_id})
     return {"status": "success", "deleted_id": playlist_id}
 
 
@@ -260,6 +308,9 @@ async def create_memory(user_id: int, description: str, date: str = None, song_i
     add_memory_vibe(memory["id"], user_id, description)
     await invalidate_list_cache("all_memories")
     await invalidate_list_cache(f"user_memories:{user_id}")
+    # Log activity to MongoDB
+    await log_user_activity(user_id, "memory_created", {"memory_id": memory["id"]})
+    await track_analytics_event("memory_added", {"memory_id": memory["id"], "user_id": user_id})
     return {"status": "success", "memory": memory}
 
 
@@ -271,6 +322,8 @@ async def delete_memory_endpoint(memory_id: int):
     remove_memory_vibe(memory_id)
     await cache_delete_pattern("list:user_memories:*")
     await invalidate_list_cache("all_memories")
+    # Log activity to MongoDB
+    await track_analytics_event("memory_deleted", {"memory_id": memory_id})
     return {"status": "success", "deleted_id": memory_id}
 
 
@@ -297,6 +350,8 @@ async def create_context(weather: str = None, time_of_day: str = None, location_
     # 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")
+    # Log activity to MongoDB
+    await track_analytics_event("context_created", {"context_id": context["id"]})
     return {"status": "success", "context": context}
 
 
@@ -307,66 +362,148 @@ async def delete_context_endpoint(context_id: int):
         raise HTTPException(status_code=404, detail="Context not found")
     remove_context_vibe(context_id)
     await invalidate_list_cache("all_contexts")
+    # Log activity to MongoDB
+    await track_analytics_event("context_deleted", {"context_id": context_id})
     return {"status": "success", "deleted_id": context_id}
 
 
-# ============== PLAY HISTORY ==============
+# ============== PLAY HISTORY (MongoDB Primary) ==============
 
 @app.get("/history")
 async def list_history(user_id: int = None, limit: int = 50):
-    """Get play history."""
+    """Get play history from MongoDB (primary storage)."""
     if user_id:
-        # Try Redis first (hot storage)
-        history = await get_user_play_history(user_id, limit)
+        # Try MongoDB first (primary storage)
+        history = await get_user_play_history_mongo(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"}
+            # Fallback to Redis
+            history = await get_redis_play_history(user_id, limit)
+            if not history:
+                # Fallback to SQLite
+                history = get_play_history(user_id, limit)
+                return {"history": history, "source": "sqlite"}
+            return {"history": history, "source": "redis"}
+        return {"history": history, "source": "mongodb"}
     else:
-        # Try Redis first (hot storage)
-        history = await get_global_play_history(limit)
+        # Try MongoDB first (primary storage)
+        history = await get_global_play_history_mongo(limit)
         if not history:
-            # Fallback to SQLite
-            history = get_play_history(None, limit)
-        return {"history": history, "source": "redis" if history else "database"}
+            # Fallback to Redis
+            history = await get_redis_global_history(limit)
+            if not history:
+                # Fallback to SQLite
+                history = get_play_history(None, limit)
+                return {"history": history, "source": "sqlite"}
+            return {"history": history, "source": "redis"}
+        return {"history": history, "source": "mongodb"}
 
 
 @app.post("/history")
-async def create_history(user_id: int, song_id: int, context_id: int = None):
-    """Add a play history entry."""
-    # Store in Redis (fast write) and SQLite (persistent)
-    redis_event = await store_play_event(user_id, song_id, context_id)
+async def create_history(user_id: int, song_id: int, context_id: int = None, duration_seconds: int = None):
+    """Add a play history entry to MongoDB (primary), Redis (cache), and SQLite (backup)."""
+    # Get song info for MongoDB storage
+    song = get_song_by_id(song_id)
+    
+    # Store in MongoDB (primary storage for analytics)
+    mongo_result = await store_play_history_mongo(
+        user_id=user_id,
+        song_id=song_id,
+        song_title=song.get("title") if song else None,
+        song_artist=song.get("artist") if song else None,
+        context_id=context_id,
+        duration_seconds=duration_seconds
+    )
+    
+    # Store in Redis (fast cache)
+    await store_play_event(user_id, song_id, context_id)
+    
+    # Store in SQLite (backup)
     sqlite_history = add_play_history(user_id, song_id, context_id)
-    return {"status": "success", "history": sqlite_history, "redis_stored": True}
+    
+    # Log analytics event
+    await track_analytics_event("song_played", {
+        "user_id": user_id,
+        "song_id": song_id,
+        "context_id": context_id
+    })
+    
+    return {
+        "status": "success",
+        "history": sqlite_history,
+        "mongodb_id": mongo_result.get("id") if mongo_result else None,
+        "redis_stored": True
+    }
+
+
+# ============== ANALYTICS ENDPOINTS (MongoDB) ==============
+
+@app.get("/analytics/summary")
+async def get_analytics(hours: int = Query(24, description="Hours to look back")):
+    """Get analytics summary from MongoDB."""
+    summary = await get_analytics_summary(hours=hours)
+    return summary
+
+
+@app.get("/analytics/top-songs")
+async def get_top_songs(limit: int = Query(10, description="Number of results")):
+    """Get top played songs from MongoDB."""
+    top_songs = await get_top_songs_mongo(limit)
+    return {"top_songs": top_songs}
+
+
+@app.get("/analytics/popular-searches")
+async def get_popular_searches_endpoint(hours: int = Query(24, description="Hours to look back"), limit: int = Query(10)):
+    """Get popular search queries from MongoDB."""
+    searches = await get_popular_searches(hours=hours, limit=limit)
+    return {"popular_searches": searches}
+
+
+@app.get("/users/{user_id}/activity")
+async def get_user_activity(user_id: int, limit: int = Query(50), action_type: str = None):
+    """Get user activity log from MongoDB."""
+    activity = await get_user_activity_mongo(user_id, limit, action_type)
+    return {"activity": activity}
 
 
 # ============== SEMANTIC SEARCH ==============
 
 @app.get("/search/songs")
-def search_songs(q: str = Query(..., description="Search query"), n: int = Query(5, description="Number of results")):
+async 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)
+    # Log search to MongoDB
+    await log_search(search_type="songs", query=q, results_count=len(results))
+    await track_analytics_event("search_performed", {"search_type": "songs", "query": q, "results": len(results)})
     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")):
+async 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)
+    # Log search to MongoDB
+    await log_search(search_type="memories", query=q, results_count=len(results))
+    await track_analytics_event("search_performed", {"search_type": "memories", "query": q, "results": len(results)})
     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")):
+async 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)
+    # Log search to MongoDB
+    await log_search(search_type="contexts", query=q, results_count=len(results))
+    await track_analytics_event("search_performed", {"search_type": "contexts", "query": q, "results": len(results)})
     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")):
+async 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)
+    # Log search to MongoDB
+    await log_search(search_type="playlists", query=q, results_count=len(results))
+    await track_analytics_event("search_performed", {"search_type": "playlists", "query": q, "results": len(results)})
     return {"query": q, "results": results}
 
 

mongo_client.py

@@ -0,0 +1,371 @@
+"""MongoDB client module for play history, activity logs, and analytics."""
+
+import os
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+from pymongo import ASCENDING, DESCENDING
+
+
+# MongoDB configuration from environment variables
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017")
+MONGO_DB_NAME = os.getenv("MONGO_DB_NAME", "music_memories")
+
+# Global MongoDB client and database instances
+_mongo_client: Optional[AsyncIOMotorClient] = None
+_mongo_db: Optional[AsyncIOMotorDatabase] = None
+
+
+def get_mongo_client() -> Optional[AsyncIOMotorClient]:
+    """Get the MongoDB client instance."""
+    return _mongo_client
+
+
+def get_mongo_db() -> Optional[AsyncIOMotorDatabase]:
+    """Get the MongoDB database instance."""
+    return _mongo_db
+
+
+async def init_mongodb() -> None:
+    """Initialize MongoDB connection."""
+    global _mongo_client, _mongo_db
+    try:
+        _mongo_client = AsyncIOMotorClient(MONGO_URI)
+        _mongo_db = _mongo_client[MONGO_DB_NAME]
+        
+        # Test connection
+        await _mongo_client.admin.command('ping')
+        print(f"✓ Connected to MongoDB at {MONGO_URI}")
+        
+        # Create indexes for play_history collection
+        await _mongo_db.play_history.create_index([("user_id", ASCENDING), ("played_at", DESCENDING)])
+        await _mongo_db.play_history.create_index([("song_id", ASCENDING)])
+        await _mongo_db.play_history.create_index([("played_at", DESCENDING)])
+        
+        # Create indexes for activity_logs collection
+        await _mongo_db.activity_logs.create_index([("user_id", ASCENDING), ("timestamp", DESCENDING)])
+        await _mongo_db.activity_logs.create_index([("action_type", ASCENDING)])
+        await _mongo_db.activity_logs.create_index([("timestamp", DESCENDING)])
+        
+        # Create indexes for analytics collection
+        await _mongo_db.analytics.create_index([("event_type", ASCENDING), ("timestamp", DESCENDING)])
+        await _mongo_db.analytics.create_index([("timestamp", DESCENDING)])
+        
+        print("✓ MongoDB indexes created")
+    except Exception as e:
+        print(f"⚠ MongoDB connection failed: {e}")
+        print("⚠ Running without MongoDB (using Redis/SQLite fallback)")
+        _mongo_client = None
+        _mongo_db = None
+
+
+async def close_mongodb() -> None:
+    """Close MongoDB connection."""
+    global _mongo_client, _mongo_db
+    if _mongo_client:
+        _mongo_client.close()
+        _mongo_client = None
+        _mongo_db = None
+
+
+# ============== Play History (MongoDB) ==============
+
+async def store_play_history_mongo(
+    user_id: int,
+    song_id: int,
+    song_title: str = None,
+    song_artist: str = None,
+    context_id: int = None,
+    duration_seconds: int = None,
+    completed: bool = True
+) -> Dict[str, Any]:
+    """Store a play history event in MongoDB."""
+    if _mongo_db is None:
+        return None
+    
+    document = {
+        "user_id": user_id,
+        "song_id": song_id,
+        "song_title": song_title,
+        "song_artist": song_artist,
+        "context_id": context_id,
+        "duration_seconds": duration_seconds,
+        "completed": completed,
+        "played_at": datetime.utcnow(),
+        "created_at": datetime.utcnow()
+    }
+    
+    result = await _mongo_db.play_history.insert_one(document)
+    return {
+        "id": str(result.inserted_id),
+        **document
+    }
+
+
+async def get_user_play_history_mongo(
+    user_id: int,
+    limit: int = 50
+) -> List[Dict[str, Any]]:
+    """Get play history for a user from MongoDB."""
+    if _mongo_db is None:
+        return []
+    
+    cursor = _mongo_db.play_history.find(
+        {"user_id": user_id}
+    ).sort("played_at", DESCENDING).limit(limit)
+    
+    results = []
+    async for doc in cursor:
+        results.append({
+            "id": str(doc["_id"]),
+            "user_id": doc["user_id"],
+            "song_id": doc["song_id"],
+            "song_title": doc.get("song_title"),
+            "song_artist": doc.get("song_artist"),
+            "context_id": doc.get("context_id"),
+            "duration_seconds": doc.get("duration_seconds"),
+            "completed": doc.get("completed", True),
+            "played_at": doc["played_at"].isoformat() if doc.get("played_at") else None
+        })
+    
+    return results
+
+
+async def get_global_play_history_mongo(
+    limit: int = 50
+) -> List[Dict[str, Any]]:
+    """Get global play history from MongoDB."""
+    if _mongo_db is None:
+        return []
+    
+    cursor = _mongo_db.play_history.find({}).sort("played_at", DESCENDING).limit(limit)
+    
+    results = []
+    async for doc in cursor:
+        results.append({
+            "id": str(doc["_id"]),
+            "user_id": doc["user_id"],
+            "song_id": doc["song_id"],
+            "song_title": doc.get("song_title"),
+            "song_artist": doc.get("song_artist"),
+            "context_id": doc.get("context_id"),
+            "duration_seconds": doc.get("duration_seconds"),
+            "completed": doc.get("completed", True),
+            "played_at": doc["played_at"].isoformat() if doc.get("played_at") else None
+        })
+    
+    return results
+
+
+async def get_song_play_count_mongo(song_id: int) -> int:
+    """Get total play count for a song."""
+    if _mongo_db is None:
+        return 0
+    
+    count = await _mongo_db.play_history.count_documents({"song_id": song_id})
+    return count
+
+
+async def get_top_songs_mongo(limit: int = 10) -> List[Dict[str, Any]]:
+    """Get top played songs from MongoDB analytics."""
+    if _mongo_db is None:
+        return []
+    
+    pipeline = [
+        {"$group": {
+            "_id": "$song_id",
+            "play_count": {"$sum": 1},
+            "song_title": {"$first": "$song_title"},
+            "song_artist": {"$first": "$song_artist"}
+        }},
+        {"$sort": {"play_count": -1}},
+        {"$limit": limit}
+    ]
+    
+    results = []
+    async for doc in _mongo_db.play_history.aggregate(pipeline):
+        results.append({
+            "song_id": doc["_id"],
+            "song_title": doc.get("song_title"),
+            "song_artist": doc.get("song_artist"),
+            "play_count": doc["play_count"]
+        })
+    
+    return results
+
+
+# ============== Activity Logs (MongoDB) ==============
+
+async def log_user_activity(
+    user_id: int,
+    action_type: str,
+    details: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    """Log a user activity event."""
+    if _mongo_db is None:
+        return None
+    
+    document = {
+        "user_id": user_id,
+        "action_type": action_type,
+        "details": details or {},
+        "timestamp": datetime.utcnow()
+    }
+    
+    result = await _mongo_db.activity_logs.insert_one(document)
+    return {
+        "id": str(result.inserted_id),
+        **document
+    }
+
+
+async def get_user_activity_mongo(
+    user_id: int,
+    limit: int = 50,
+    action_type: str = None
+) -> List[Dict[str, Any]]:
+    """Get activity logs for a user."""
+    if _mongo_db is None:
+        return []
+    
+    query = {"user_id": user_id}
+    if action_type:
+        query["action_type"] = action_type
+    
+    cursor = _mongo_db.activity_logs.find(query).sort("timestamp", DESCENDING).limit(limit)
+    
+    results = []
+    async for doc in cursor:
+        results.append({
+            "id": str(doc["_id"]),
+            "user_id": doc["user_id"],
+            "action_type": doc["action_type"],
+            "details": doc.get("details", {}),
+            "timestamp": doc["timestamp"].isoformat() if doc.get("timestamp") else None
+        })
+    
+    return results
+
+
+# ============== Analytics Events (MongoDB) ==============
+
+async def track_analytics_event(
+    event_type: str,
+    properties: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    """Track an analytics event."""
+    if _mongo_db is None:
+        return None
+    
+    document = {
+        "event_type": event_type,
+        "properties": properties or {},
+        "timestamp": datetime.utcnow()
+    }
+    
+    result = await _mongo_db.analytics.insert_one(document)
+    return {
+        "id": str(result.inserted_id),
+        **document
+    }
+
+
+async def get_analytics_summary(
+    event_type: str = None,
+    hours: int = 24
+) -> Dict[str, Any]:
+    """Get analytics summary for the last N hours."""
+    if _mongo_db is None:
+        return {}
+    
+    from datetime import timedelta
+    since = datetime.utcnow() - timedelta(hours=hours)
+    
+    query = {"timestamp": {"$gte": since}}
+    if event_type:
+        query["event_type"] = event_type
+    
+    total_events = await _mongo_db.analytics.count_documents(query)
+    
+    # Get event type breakdown
+    pipeline = [
+        {"$match": query},
+        {"$group": {
+            "_id": "$event_type",
+            "count": {"$sum": 1}
+        }},
+        {"$sort": {"count": -1}}
+    ]
+    
+    breakdown = []
+    async for doc in _mongo_db.analytics.aggregate(pipeline):
+        breakdown.append({
+            "event_type": doc["_id"],
+            "count": doc["count"]
+        })
+    
+    return {
+        "total_events": total_events,
+        "period_hours": hours,
+        "breakdown": breakdown
+    }
+
+
+# ============== User Search History (MongoDB) ==============
+
+async def log_search(
+    user_id: int = None,
+    search_type: str = None,
+    query: str = None,
+    results_count: int = 0
+) -> Dict[str, Any]:
+    """Log a search event."""
+    if _mongo_db is None:
+        return None
+    
+    document = {
+        "user_id": user_id,
+        "search_type": search_type,
+        "query": query,
+        "results_count": results_count,
+        "timestamp": datetime.utcnow()
+    }
+    
+    result = await _mongo_db.search_history.insert_one(document)
+    return {
+        "id": str(result.inserted_id),
+        **document
+    }
+
+
+async def get_popular_searches(
+    hours: int = 24,
+    limit: int = 10
+) -> List[Dict[str, Any]]:
+    """Get popular search queries."""
+    if _mongo_db is None:
+        return []
+    
+    from datetime import timedelta
+    since = datetime.utcnow() - timedelta(hours=hours)
+    
+    pipeline = [
+        {"$match": {"timestamp": {"$gte": since}}},
+        {"$group": {
+            "_id": "$query",
+            "count": {"$sum": 1},
+            "search_type": {"$first": "$search_type"}
+        }},
+        {"$sort": {"count": -1}},
+        {"$limit": limit}
+    ]
+    
+    results = []
+    async for doc in _mongo_db.search_history.aggregate(pipeline):
+        results.append({
+            "query": doc["_id"],
+            "search_type": doc.get("search_type"),
+            "count": doc["count"]
+        })
+    
+    return results

pyproject.toml

@@ -14,6 +14,8 @@ dependencies = [
    "huggingface-hub>=1.8.0",
    "peft>=0.18.1",
    "redis>=5.0.0",
+   "pymongo>=4.6.0",
+   "motor>=3.4.0",
    "sentence-transformers>=3.0.0",
    "torch>=2.5.0",
    "torchaudio>=2.5.0",