@ngocsangairvds/vsaf 3.2.15 → 4.0.0

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/service/services/analytics_service.py

@@ -1,2825 +0,0 @@
-"""
-VDS AI Memory Analytics Service
-
-Comprehensive analytics service for memory usage, performance monitoring,
-trend analysis, and AI-powered insights generation.
-"""
-
-import asyncio
-import json
-import logging
-import statistics
-import uuid
-from collections import defaultdict
-from collections.abc import Callable
-from datetime import UTC, datetime, timedelta
-from typing import Any, TypeVar
-
-from sqlalchemy import and_, case, desc, func, select, text
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import Session
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    ValidationError,
-)
-from vds_memory_orchestrator.service.core.config import (
-    REDIS_ANALYTICS_DB,
-    REDIS_SEARCH_CACHE_DB,
-    REDIS_SESSION_STORE_DB,
-    get_config,
-)
-from vds_memory_orchestrator.service.database.redis_manager import redis_manager
-from vds_memory_orchestrator.service.models.analytics_models import (
-    AlertSeverity,
-    AnalyticsAlert,
-    AnalyticsDashboard,
-    AnalyticsReport,
-    AnalyticsRequest,
-    AnalyticsScope,
-    BusinessIntelligenceReport,
-    BusinessKPI,
-    ChartData,
-    CollaborationAnalytics,
-    DashboardCreateRequest,
-    DashboardWidget,
-    GeneratedInsight,
-    InsightCategory,
-    InsightSeverity,
-    MemoryContentAnalytics,
-    MemoryMetric,
-    PerformanceAnalytics,
-    PredictiveMetric,
-    RealTimeMetrics,
-    ReportTemplate,
-    ReportTemplateCreateRequest,
-    ReportTemplateGenerateRequest,
-    SearchAnalytics,
-    TimeGranularity,
-    TrendAnalysis,
-    TrendDirection,
-    UsageTrend,
-    UserActivityMetrics,
-)
-from vds_memory_orchestrator.service.models.database import (
-    ExportImportJob,
-    MemoryRecord,
-    SearchQuery,
-)
-from vds_memory_orchestrator.service.services.analytics_events import (
-    CACHE_SAMPLE_KEY,
-    MEMORY_EVENT_KEY,
-    RESPONSE_SAMPLE_KEY,
-    SEARCH_EVENT_KEY,
-)
-from vds_memory_orchestrator.service.services.health_check import HealthCheckService
-
-logger = logging.getLogger(__name__)
-config = get_config()
-T = TypeVar("T")
-
-REALTIME_MEMORY_WINDOW_SECONDS = 300
-REALTIME_SEARCH_WINDOW_SECONDS = 60
-REALTIME_CONCURRENT_WINDOW_SECONDS = 10
-RESPONSE_SAMPLE_WINDOW_SECONDS = 60
-CACHE_SAMPLE_WINDOW_SECONDS = 120
-MAX_SAMPLE_LENGTH = 300
-REPORT_TEMPLATE_PREFIX = "report_template"
-ALERT_LIST_KEY = "analytics:alerts"
-ALERT_TTL_SECONDS = 86400  # retain 24h of alerts
-ALERT_HISTORY_LIMIT = 100
-RESPONSE_TIME_WARNING_MS = 300.0
-RESPONSE_TIME_CRITICAL_MS = 500.0
-ERROR_RATE_WARNING = 0.03
-ERROR_RATE_CRITICAL = 0.05
-SYSTEM_LOAD_WARNING = 0.75
-SYSTEM_LOAD_CRITICAL = 0.9
-CACHE_HIT_WARNING = 0.75
-
-# User ID prefixes that identify internal healthcheck/test accounts.
-# Used by the include_internal filter to exclude probe data from production reports.
-_INTERNAL_USER_PREFIXES = ("_healthcheck_", "_test_")
-
-
-def _is_internal_user_id(user_id: str) -> bool:
-    """Return True if user_id matches an internal healthcheck/test prefix."""
-    return any(user_id.startswith(p) for p in _INTERNAL_USER_PREFIXES)
-
-
-class AnalyticsService:
-    """Comprehensive analytics service for memory management."""
-
-    def __init__(self, db: Session | AsyncSession):
-        self.db = db
-        self.config = config
-        self.analytics_cache_ttl = config.redis.analytics_cache_ttl
-        self.real_time_metrics_ttl = config.redis.real_time_metrics_ttl
-        self._is_async_session = isinstance(db, AsyncSession)
-
-    async def _run_in_session(self, fn: Callable[[Session], T]) -> T:
-        """Execute a synchronous ORM operation regardless of session type."""
-        if self._is_async_session:
-            return await self.db.run_sync(fn)
-        return fn(self.db)
-
-    async def get_user_activity_metrics(
-        self,
-        user_id: str,
-        time_range_days: int = 30,
-        include_internal: bool = False,
-    ) -> UserActivityMetrics:
-        """Generate comprehensive user activity analytics."""
-        try:
-            if not include_internal and _is_internal_user_id(user_id):
-                return UserActivityMetrics(
-                    user_id=self._safe_user_uuid(user_id),
-                    total_memories=0,
-                    memories_created_today=0,
-                    memories_this_week=0,
-                    memories_this_month=0,
-                    avg_memories_per_day=0.0,
-                    most_active_hour=0,
-                    most_active_day="N/A",
-                    total_searches=0,
-                    avg_search_results=0.0,
-                    search_success_rate=0.0,
-                    shared_memories=0,
-                    collaboration_count=0,
-                    export_count=0,
-                    import_count=0,
-                    last_activity=datetime.now(UTC),
-                    activity_streak=0,
-                )
-
-            now_utc = datetime.now(UTC)
-            now = now_utc.replace(tzinfo=None)
-            cutoff_date = now - timedelta(days=time_range_days)
-            today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
-            week_ago = now - timedelta(days=7)
-            month_ago = now - timedelta(days=30)
-
-            total_memories = await self._run_in_session(
-                lambda session: (
-                    session.query(MemoryRecord).filter(MemoryRecord.user_id == user_id).count()
-                )
-            )
-
-            memories_today = await self._run_in_session(
-                lambda session: (
-                    session.query(MemoryRecord)
-                    .filter(
-                        and_(
-                            MemoryRecord.user_id == user_id,
-                            MemoryRecord.created_at >= today_start,
-                        )
-                    )
-                    .count()
-                )
-            )
-
-            memories_this_week = await self._run_in_session(
-                lambda session: (
-                    session.query(MemoryRecord)
-                    .filter(
-                        and_(
-                            MemoryRecord.user_id == user_id,
-                            MemoryRecord.created_at >= week_ago,
-                        )
-                    )
-                    .count()
-                )
-            )
-
-            memories_this_month = await self._run_in_session(
-                lambda session: (
-                    session.query(MemoryRecord)
-                    .filter(
-                        and_(
-                            MemoryRecord.user_id == user_id,
-                            MemoryRecord.created_at >= month_ago,
-                        )
-                    )
-                    .count()
-                )
-            )
-
-            avg_memories_per_day = total_memories / max(1, time_range_days)
-
-            activity_data = await self._run_in_session(
-                lambda session: (
-                    session.query(
-                        func.extract("hour", MemoryRecord.created_at).label("hour"),
-                        func.extract("dow", MemoryRecord.created_at).label("day_of_week"),
-                        func.count(MemoryRecord.memory_id).label("count"),
-                    )
-                    .filter(
-                        and_(
-                            MemoryRecord.user_id == user_id,
-                            MemoryRecord.created_at >= cutoff_date,
-                        )
-                    )
-                    .group_by("hour", "day_of_week")
-                    .all()
-                )
-            )
-
-            most_active_hour = 10  # Default
-            most_active_day = "Monday"  # Default
-            day_names = [
-                "Sunday",
-                "Monday",
-                "Tuesday",
-                "Wednesday",
-                "Thursday",
-                "Friday",
-                "Saturday",
-            ]
-
-            if activity_data:
-                # Find most active hour
-                hour_counts = defaultdict(int)
-                for hour, _, count in activity_data:
-                    hour_counts[int(hour)] += count
-                most_active_hour = max(hour_counts.items(), key=lambda x: x[1])[0]
-
-                # Find most active day
-                day_counts = defaultdict(int)
-                for _, day, count in activity_data:
-                    day_counts[int(day)] += count
-                most_active_day = day_names[max(day_counts.items(), key=lambda x: x[1])[0]]
-
-            # Search and collaboration metrics (would come from Redis logs)
-            search_metrics = await self._get_user_search_metrics(user_id, time_range_days)
-            collaboration_metrics = await self._get_user_collaboration_metrics(
-                user_id, time_range_days
-            )
-
-            last_memory = await self._run_in_session(
-                lambda session: (
-                    session.query(MemoryRecord)
-                    .filter(MemoryRecord.user_id == user_id)
-                    .order_by(desc(MemoryRecord.created_at))
-                    .first()
-                )
-            )
-
-            if last_memory and last_memory.created_at:
-                last_activity = last_memory.created_at.replace(tzinfo=UTC)
-            else:
-                last_activity = now_utc
-
-            # Activity streak calculation
-            activity_streak = await self._calculate_activity_streak(user_id)
-
-            safe_uuid = self._safe_user_uuid(user_id)
-
-            return UserActivityMetrics(
-                user_id=safe_uuid,
-                total_memories=total_memories,
-                memories_created_today=memories_today,
-                memories_this_week=memories_this_week,
-                memories_this_month=memories_this_month,
-                avg_memories_per_day=avg_memories_per_day,
-                most_active_hour=most_active_hour,
-                most_active_day=most_active_day,
-                total_searches=search_metrics.get("total_searches", 0),
-                avg_search_results=search_metrics.get("avg_results", 0.0),
-                search_success_rate=search_metrics.get("success_rate", 0.0),
-                shared_memories=collaboration_metrics.get("shared_memories", 0),
-                collaboration_count=collaboration_metrics.get("collaboration_count", 0),
-                export_count=collaboration_metrics.get("export_count", 0),
-                import_count=collaboration_metrics.get("import_count", 0),
-                last_activity=last_activity,
-                activity_streak=activity_streak,
-            )
-
-        except Exception as e:
-            logger.exception("Failed to generate user metrics for %s: %s", user_id, e)
-            raise
-
-    async def get_memory_growth_series(
-        self,
-        user_id: str | None,
-        scope: AnalyticsScope,
-        time_range_days: int = 30,
-        include_internal: bool = False,
-    ) -> list[dict[str, Any]]:
-        """Return a daily memory creation series for dashboard charts."""
-        cutoff_date = datetime.now(UTC).replace(tzinfo=None) - timedelta(days=time_range_days)
-
-        def _query(session: Session) -> list[dict[str, Any]]:
-            base = session.query(
-                func.date_trunc("day", MemoryRecord.created_at).label("day"),
-                func.count(MemoryRecord.memory_id).label("count"),
-            ).filter(MemoryRecord.created_at >= cutoff_date)
-            if scope == AnalyticsScope.USER and user_id:
-                base = base.filter(MemoryRecord.user_id == user_id)
-            if not include_internal:
-                base = base.filter(
-                    ~MemoryRecord.user_id.like("_healthcheck_%"),
-                    ~MemoryRecord.user_id.like("_test_%"),
-                )
-            rows = base.group_by("day").order_by("day").all()
-            return [{"date": row.day.date().isoformat(), "value": int(row.count)} for row in rows]
-
-        return await self._run_in_session(_query)
-
-    async def get_memory_content_analytics(
-        self, user_id: str | None = None, scope: AnalyticsScope = AnalyticsScope.USER
-    ) -> MemoryContentAnalytics:
-        """Generate content analytics and insights."""
-        try:
-
-            def _fetch_memories(session: Session):
-                query = session.query(MemoryRecord)
-                if scope == AnalyticsScope.USER and user_id:
-                    query = query.filter(MemoryRecord.user_id == user_id)
-                return query.all()
-
-            memories = await self._run_in_session(_fetch_memories)
-            total_memories = len(memories)
-
-            content_lengths: list[int] = []
-            title_lengths: list[int] = []
-            categories: list[str] = []
-            importance_levels: list[str] = []
-            all_tags: list[str] = []
-
-            for memory in memories:
-                content_lengths.append(len(memory.content) if memory.content else 0)
-                title_lengths.append(len(memory.title) if memory.title else 0)
-                if memory.category:
-                    categories.append(memory.category)
-                if memory.importance:
-                    importance_levels.append(memory.importance)
-                if memory.tags:
-                    all_tags.extend(memory.tags)
-
-            avg_content_length = statistics.mean(content_lengths) if content_lengths else 0
-            avg_title_length = statistics.mean(title_lengths) if title_lengths else 0
-
-            category_counts: dict[str, int] = {}
-            for category in categories:
-                category_counts[category] = category_counts.get(category, 0) + 1
-
-            most_used_categories = [
-                {"category": cat, "count": count}
-                for cat, count in sorted(category_counts.items(), key=lambda x: x[1], reverse=True)[
-                    :10
-                ]
-            ]
-
-            importance_distribution: dict[str, int] = {}
-            for level in importance_levels:
-                importance_distribution[level] = importance_distribution.get(level, 0) + 1
-
-            tag_frequency: dict[str, int] = {}
-            for tag in all_tags:
-                tag_frequency[tag] = tag_frequency.get(tag, 0) + 1
-
-            language_distribution = {"english": 0, "non_english": 0}
-            sentiment_distribution = {"positive": 0, "neutral": 0, "negative": 0}
-            positive_terms = {
-                "success",
-                "improved",
-                "good",
-                "great",
-                "resolved",
-                "completed",
-                "approved",
-                "fast",
-                "stable",
-            }
-            negative_terms = {
-                "error",
-                "failed",
-                "issue",
-                "bug",
-                "slow",
-                "blocked",
-                "delay",
-                "critical",
-                "outage",
-            }
-
-            for memory in memories:
-                text = (memory.content or "").strip()
-                if text:
-                    ascii_ratio = sum(1 for ch in text if ord(ch) < 128) / max(1, len(text))
-                    if ascii_ratio >= 0.95:
-                        language_distribution["english"] += 1
-                    else:
-                        language_distribution["non_english"] += 1
-
-                    tokens = {
-                        token.strip(".,:;!?()[]{}").lower() for token in text.split() if token
-                    }
-                    sentiment_score = len(tokens & positive_terms) - len(tokens & negative_terms)
-                    if sentiment_score > 0:
-                        sentiment_distribution["positive"] += 1
-                    elif sentiment_score < 0:
-                        sentiment_distribution["negative"] += 1
-                    else:
-                        sentiment_distribution["neutral"] += 1
-
-            if sum(language_distribution.values()) == 0:
-                language_distribution["english"] = total_memories
-
-            content_themes = [
-                item["category"] for item in most_used_categories[:5] if item.get("category")
-            ]
-            if not content_themes:
-                # Phase 196 fix: was `dict(...)[:5].keys()` — dicts don't support
-                # slice subscripting in Python 3 (TypeError: slice(None, 5, None)).
-                # Slice the sorted list FIRST, then dict() it, then take .keys().
-                content_themes = list(
-                    dict(sorted(tag_frequency.items(), key=lambda x: x[1], reverse=True)[:5]).keys()
-                )
-
-            growth_metrics = await self._calculate_content_growth_metrics(memories)
-
-            return MemoryContentAnalytics(
-                total_memories=total_memories,
-                avg_content_length=avg_content_length,
-                avg_title_length=avg_title_length,
-                most_used_categories=most_used_categories,
-                category_distribution=category_counts,
-                importance_distribution=importance_distribution,
-                tag_frequency=dict(
-                    sorted(tag_frequency.items(), key=lambda x: x[1], reverse=True)[:50]
-                ),
-                content_language_distribution=language_distribution,
-                sentiment_distribution=sentiment_distribution,
-                content_themes=content_themes,
-                growth_metrics=growth_metrics,
-            )
-
-        except Exception as e:
-            logger.exception("Failed to generate content analytics: %s", e)
-            raise
-
-    async def get_search_analytics(
-        self,
-        user_id: str | None = None,
-        scope: AnalyticsScope = AnalyticsScope.USER,
-        time_range_days: int = 30,
-    ) -> SearchAnalytics:
-        """Generate search behavior analytics."""
-        try:
-            # Search analytics derived from stored search queries and filters
-
-            search_data = await self._get_search_log_data(user_id, scope, time_range_days)
-
-            total_searches = search_data.get("total_searches", 0)
-            unique_queries = len(search_data.get("unique_terms", []))
-            avg_results_per_search = search_data.get("avg_results", 0.0)
-            search_success_rate = search_data.get("success_rate", 0.0)
-            no_result_queries = search_data.get("no_result_queries", 0)
-
-            # Popular search terms
-            popular_search_terms = search_data.get("popular_terms", [])
-
-            # Algorithm usage statistics
-            search_algorithm_usage = search_data.get("algorithm_usage", {})
-
-            # Filter usage statistics
-            filter_usage = search_data.get("filter_usage", {})
-
-            # Average search duration
-            avg_search_duration = (
-                search_data.get("avg_duration_ms", 0) / 1000.0
-            )  # Convert to seconds
-
-            # Search trends over time
-            search_trends = search_data.get("daily_trends", [])
-
-            # Query patterns analysis
-            query_patterns = search_data.get("query_patterns", [])
-
-            # Seasonal trends
-            seasonal_trends = search_data.get("seasonal_trends", {})
-
-            return SearchAnalytics(
-                total_searches=total_searches,
-                unique_queries=unique_queries,
-                avg_results_per_search=avg_results_per_search,
-                search_success_rate=search_success_rate,
-                no_result_queries=no_result_queries,
-                popular_search_terms=popular_search_terms,
-                search_algorithm_usage=search_algorithm_usage,
-                filter_usage=filter_usage,
-                avg_search_duration=avg_search_duration,
-                search_trends=search_trends,
-                query_patterns=query_patterns,
-                seasonal_trends=seasonal_trends,
-            )
-
-        except Exception as e:
-            logger.exception(f"Error generating search analytics: {str(e)}")
-            raise
-
-    async def get_collaboration_analytics(
-        self,
-        user_id: str | None = None,
-        scope: AnalyticsScope = AnalyticsScope.USER,
-        time_range_days: int = 30,
-    ) -> CollaborationAnalytics:
-        """Generate collaboration and sharing analytics."""
-        try:
-            # Collaboration analytics derived from shared memory records
-
-            collaboration_data = await self._get_collaboration_log_data(
-                user_id, scope, time_range_days
-            )
-
-            total_shares = collaboration_data.get("total_shares", 0)
-            shared_with_users = collaboration_data.get("unique_users_shared", 0)
-            shared_with_teams = collaboration_data.get("unique_teams_shared", 0)
-            public_shares = collaboration_data.get("public_shares", 0)
-
-            # Collaboration sessions and metrics
-            collaboration_sessions = collaboration_data.get("collaboration_sessions", 0)
-            concurrent_collaborations = collaboration_data.get("max_concurrent", 1)
-            avg_collaboration_duration = collaboration_data.get("avg_duration_minutes", 0.0)
-
-            # Most collaborated memories
-            most_collaborative_memories = collaboration_data.get("top_memories", [])
-
-            # Success rate and activity metrics
-            collaboration_success_rate = collaboration_data.get("success_rate", 0.0)
-            permission_changes = collaboration_data.get("permission_changes", 0)
-            external_collaborations = collaboration_data.get("external_collaborations", 0)
-
-            return CollaborationAnalytics(
-                total_shares=total_shares,
-                shared_with_users=shared_with_users,
-                shared_with_teams=shared_with_teams,
-                public_shares=public_shares,
-                collaboration_sessions=collaboration_sessions,
-                concurrent_collaborations=concurrent_collaborations,
-                avg_collaboration_duration=avg_collaboration_duration,
-                most_collaborative_memories=most_collaborative_memories,
-                collaboration_success_rate=collaboration_success_rate,
-                permission_changes=permission_changes,
-                external_collaborations=external_collaborations,
-            )
-
-        except Exception as e:
-            logger.exception(f"Error generating collaboration analytics: {str(e)}")
-            raise
-
-    async def get_performance_analytics(self) -> PerformanceAnalytics:
-        """Generate system performance analytics."""
-        try:
-            performance_data = await self._get_performance_metrics()
-
-            # Response time metrics
-            avg_response_time = float(performance_data.get("avg_response_time_ms", 0.0))
-            p95_response_time = float(performance_data.get("p95_response_time_ms", 0.0))
-            p99_response_time = float(performance_data.get("p99_response_time_ms", 0.0))
-
-            # Error and throughput metrics
-            error_rate = float(performance_data.get("error_rate", 0.0))
-            throughput = float(performance_data.get("requests_per_second", 0.0))
-
-            # User and system metrics
-            concurrent_users = int(performance_data.get("concurrent_users", 0))
-            cache_hit_rate = float(performance_data.get("cache_hit_rate", 0.0))
-
-            database_performance = performance_data.get("database_performance", {})
-            api_performance = performance_data.get("api_performance", {})
-            memory_usage = performance_data.get("memory_usage", {})
-            cpu_usage = performance_data.get("cpu_usage", {})
-            storage_metrics = performance_data.get("storage_metrics", {})
-
-            return PerformanceAnalytics(
-                avg_response_time=avg_response_time,
-                p95_response_time=p95_response_time,
-                p99_response_time=p99_response_time,
-                error_rate=error_rate,
-                throughput=throughput,
-                concurrent_users=concurrent_users,
-                cache_hit_rate=cache_hit_rate,
-                database_performance=database_performance,
-                api_performance=api_performance,
-                memory_usage=memory_usage,
-                cpu_usage=cpu_usage,
-                storage_metrics=storage_metrics,
-            )
-
-        except Exception as e:
-            logger.exception(f"Error generating performance analytics: {str(e)}")
-            raise
-
-    async def generate_insights(
-        self, user_id: str | None = None, scope: AnalyticsScope = AnalyticsScope.USER
-    ) -> list[GeneratedInsight]:
-        """Generate AI-powered insights from analytics data."""
-        try:
-            insights = []
-
-            # Generate usage insights
-            usage_insights = await self._generate_usage_insights(user_id, scope)
-            insights.extend(usage_insights)
-
-            # Generate performance insights
-            performance_insights = await self._generate_performance_insights()
-            insights.extend(performance_insights)
-
-            # Generate collaboration insights
-            if scope in [AnalyticsScope.USER, AnalyticsScope.TEAM]:
-                collaboration_insights = await self._generate_collaboration_insights(user_id, scope)
-                insights.extend(collaboration_insights)
-
-            # Generate content insights
-            content_insights = await self._generate_content_insights(user_id, scope)
-            insights.extend(content_insights)
-
-            # Sort by confidence and severity
-            insights.sort(key=lambda x: (x.confidence_score, x.severity.value), reverse=True)
-
-            return insights[:10]  # Return top 10 insights
-
-        except Exception as e:
-            logger.exception(f"Error generating insights: {str(e)}")
-            raise
-
-    async def get_trend_analysis(
-        self,
-        metric_name: str,
-        time_range_days: int = 30,
-        granularity: TimeGranularity = TimeGranularity.DAILY,
-    ) -> TrendAnalysis:
-        """Generate trend analysis for a specific metric."""
-        try:
-            # Get historical data points
-            trend_points = await self._get_historical_metric_data(
-                metric_name, time_range_days, granularity
-            )
-
-            if not trend_points:
-                raise ValueError(f"No data available for metric: {metric_name}")
-
-            # Calculate trend direction and growth rate
-            values = [
-                point.value for point in trend_points if isinstance(point.value, (int, float))
-            ]
-            if len(values) < 2:
-                trend_direction = TrendDirection.STABLE
-                growth_rate = 0.0
-            else:
-                # Simple linear regression for trend
-                x_values = list(range(len(values)))
-                slope = self._calculate_linear_regression_slope(x_values, values)
-
-                if slope > 0.1:
-                    trend_direction = TrendDirection.UP
-                elif slope < -0.1:
-                    trend_direction = TrendDirection.DOWN
-                else:
-                    trend_direction = TrendDirection.STABLE
-
-                # Calculate growth rate
-                growth_rate = (values[-1] - values[0]) / values[0] * 100 if values[0] != 0 else 0.0
-
-            # Calculate volatility
-            if len(values) > 1:
-                volatility_score = statistics.stdev(values) / (
-                    statistics.mean(values) if statistics.mean(values) != 0 else 1
-                )
-                volatility_score = min(volatility_score, 1.0)  # Cap at 1.0
-            else:
-                volatility_score = 0.0
-
-            # Seasonal pattern detection (simplified)
-            seasonal_pattern = await self._detect_seasonal_pattern(trend_points)
-
-            # Generate forecast (simple moving average with trend)
-            forecast_next_period = None
-            confidence_interval = None
-
-            if len(values) >= 3:
-                recent_avg = statistics.mean(values[-3:])
-                if slope != 0:
-                    forecast_next_period = recent_avg + slope
-                    confidence_interval = {
-                        "lower": forecast_next_period - (volatility_score * recent_avg),
-                        "upper": forecast_next_period + (volatility_score * recent_avg),
-                    }
-
-            # Generate insights
-            insights = []
-            if trend_direction == TrendDirection.UP and growth_rate > 10:
-                insights.append(f"Strong upward trend detected with {growth_rate:.1f}% growth")
-            elif trend_direction == TrendDirection.DOWN and growth_rate < -10:
-                insights.append(f"Declining trend detected with {abs(growth_rate):.1f}% decrease")
-            elif seasonal_pattern:
-                insights.append("Seasonal pattern detected in metric data")
-
-            return TrendAnalysis(
-                metric_name=metric_name,
-                time_period=f"Last {time_range_days} days",
-                granularity=granularity,
-                trend_direction=trend_direction,
-                growth_rate=growth_rate,
-                seasonal_pattern=seasonal_pattern,
-                volatility_score=volatility_score,
-                forecast_next_period=forecast_next_period,
-                confidence_interval=confidence_interval,
-                trend_points=trend_points,
-                insights=insights,
-            )
-
-        except Exception as e:
-            logger.exception(f"Error generating trend analysis: {str(e)}")
-            raise
-
-    async def get_predictive_metrics(
-        self,
-        metric_names: list[str],
-        time_range_days: int = 30,
-        forecast_horizon_hours: int = 24,
-        granularity: TimeGranularity = TimeGranularity.DAILY,
-    ) -> list[PredictiveMetric]:
-        """Generate predictive analytics for multiple metrics."""
-        predictions: list[PredictiveMetric] = []
-
-        for metric in metric_names:
-            try:
-                trend = await self.get_trend_analysis(metric, time_range_days, granularity)
-            except Exception as exc:  # continue even if one metric fails
-                logger.warning("Trend analysis failed for %s: %s", metric, exc)
-                continue
-
-            values = [
-                point.value for point in trend.trend_points if isinstance(point.value, (int, float))
-            ]
-            if not values:
-                continue
-
-            current_value = values[0]
-            forecast_value = trend.forecast_next_period
-            if forecast_value is None:
-                recent_slice = values[:3] if len(values) >= 3 else values
-                forecast_value = statistics.mean(recent_slice)
-
-            confidence_interval = trend.confidence_interval or {
-                "lower": float(forecast_value) * 0.9,
-                "upper": float(forecast_value) * 1.1,
-            }
-
-            risk_level = "low"
-            if trend.trend_direction == TrendDirection.DOWN and trend.growth_rate < -5:
-                risk_level = "high"
-            elif trend.trend_direction == TrendDirection.DOWN or trend.volatility_score > 0.5:
-                risk_level = "medium"
-
-            insights = list(trend.insights)
-            if risk_level == "high":
-                insights.append("Mitigate decline to avoid breaching targets")
-
-            predictions.append(
-                PredictiveMetric(
-                    metric_name=metric,
-                    horizon_hours=forecast_horizon_hours,
-                    current_value=float(current_value),
-                    forecast_value=float(forecast_value),
-                    confidence_interval=confidence_interval,
-                    trend_direction=trend.trend_direction,
-                    growth_rate=trend.growth_rate,
-                    risk_level=risk_level,
-                    insights=insights,
-                )
-            )
-
-        return predictions
-
-    async def create_dashboard(
-        self,
-        request: DashboardCreateRequest,
-        user_id: str | None = None,
-    ) -> AnalyticsDashboard:
-        """Create a custom analytics dashboard."""
-
-        try:
-            dashboard_id = uuid.uuid4()
-            owner_uuid: uuid.UUID | None = None
-            if user_id:
-                try:
-                    owner_uuid = uuid.UUID(user_id)
-                except ValueError:
-                    logger.warning("Invalid user_id provided for dashboard owner: %s", user_id)
-
-            widget_definitions = [
-                self._build_dashboard_widget(widget) for widget in request.widgets
-            ]
-
-            dashboard = AnalyticsDashboard(
-                dashboard_id=dashboard_id,
-                title=request.title,
-                description=request.description,
-                scope=request.scope,
-                user_id=owner_uuid,
-                widgets=widget_definitions,
-                layout=request.layout or {"type": "grid", "columns": 12},
-                filters=request.filters or {},
-                time_range=request.time_range or {"default_days": 30, "presets": [7, 30, 90]},
-                is_public=request.is_public,
-                metadata=request.metadata,
-            )
-
-            await self._save_dashboard_configuration(dashboard)
-
-            return dashboard
-
-        except Exception as e:
-            logger.exception(f"Error creating dashboard: {str(e)}")
-            raise
-
-    async def list_dashboards(
-        self,
-        user_id: str | None = None,
-        scope: AnalyticsScope | None = None,
-    ) -> list[AnalyticsDashboard]:
-        """List dashboards available to the caller."""
-
-        dashboard_ids: set[str] = set()
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            if user_id:
-                user_key = f"user_dashboards:{user_id}"
-                user_dashboards = await conn.smembers(user_key)
-                for entry in user_dashboards or []:
-                    dashboard_ids.add(entry if isinstance(entry, str) else entry.decode("utf-8"))
-
-            cursor: Any = 0
-            while True:
-                cursor, keys = await conn.scan(cursor=cursor, match="dashboard:*", count=200)
-                for key in keys:
-                    key_str = key if isinstance(key, str) else key.decode("utf-8")
-                    dashboard_ids.add(key_str.split("dashboard:", 1)[1])
-                if int(cursor) == 0:
-                    break
-
-        dashboards: list[AnalyticsDashboard] = []
-        for dashboard_id in dashboard_ids:
-            dashboard = await self.get_dashboard(dashboard_id)
-            if not dashboard:
-                continue
-            if scope and dashboard.scope != scope:
-                continue
-            if (
-                user_id
-                and dashboard.scope == AnalyticsScope.USER
-                and dashboard.user_id
-                and str(dashboard.user_id) != user_id
-            ):
-                continue
-            dashboards.append(dashboard)
-
-        dashboards.sort(key=lambda item: item.updated_at, reverse=True)
-        return dashboards
-
-    async def get_dashboard(self, dashboard_id: str) -> AnalyticsDashboard | None:
-        """Fetch a dashboard by identifier."""
-
-        return await self._load_dashboard_configuration(dashboard_id)
-
-    async def delete_dashboard(
-        self,
-        dashboard_id: str,
-        user_id: str | None = None,
-    ) -> bool:
-        """Delete a dashboard configuration."""
-
-        dashboard = await self.get_dashboard(dashboard_id)
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            await conn.delete(f"dashboard:{dashboard_id}")
-            if dashboard and dashboard.user_id:
-                await conn.srem(f"user_dashboards:{dashboard.user_id}", dashboard_id)
-            if user_id:
-                await conn.srem(f"user_dashboards:{user_id}", dashboard_id)
-        return dashboard is not None
-
-    async def create_report_template(
-        self,
-        payload: ReportTemplateCreateRequest,
-        owner_id: str | None = None,
-    ) -> ReportTemplate:
-        owner_uuid = None
-        if owner_id:
-            try:
-                owner_uuid = uuid.UUID(owner_id)
-            except ValueError:
-                logger.warning("Invalid owner_id provided for report template: %s", owner_id)
-
-        template = ReportTemplate(
-            name=payload.name,
-            description=payload.description,
-            owner_id=owner_uuid,
-            scope=payload.scope,
-            metric_names=payload.metric_names,
-            granularity=payload.granularity,
-            default_time_range_days=payload.default_time_range_days,
-            filters=payload.filters,
-            include_forecasts=payload.include_forecasts,
-            include_insights=payload.include_insights,
-            delivery_format=payload.delivery_format,
-            metadata=payload.metadata,
-        )
-
-        await self._save_report_template(template)
-        return template
-
-    async def list_report_templates(
-        self,
-        user_id: str | None = None,
-        scope: AnalyticsScope | None = None,
-    ) -> list[ReportTemplate]:
-        template_ids: set[str] = set()
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            if user_id:
-                owner_key = f"user_report_templates:{user_id}"
-                owned = await conn.smembers(owner_key)
-                for entry in owned or []:
-                    template_ids.add(entry if isinstance(entry, str) else entry.decode("utf-8"))
-
-            cursor: Any = 0
-            while True:
-                cursor, keys = await conn.scan(
-                    cursor=cursor,
-                    match=f"{REPORT_TEMPLATE_PREFIX}:*",
-                    count=200,
-                )
-                for key in keys:
-                    key_str = key if isinstance(key, str) else key.decode("utf-8")
-                    template_ids.add(key_str.split(f"{REPORT_TEMPLATE_PREFIX}:", 1)[1])
-                if int(cursor) == 0:
-                    break
-
-        templates: list[ReportTemplate] = []
-        for template_id in template_ids:
-            template = await self.get_report_template(template_id)
-            if not template:
-                continue
-            if scope and template.scope != scope:
-                continue
-            if (
-                user_id
-                and template.scope == AnalyticsScope.USER
-                and template.owner_id
-                and str(template.owner_id) != user_id
-            ):
-                continue
-            templates.append(template)
-
-        templates.sort(key=lambda tpl: tpl.updated_at, reverse=True)
-        return templates
-
-    async def get_report_template(self, template_id: str) -> ReportTemplate | None:
-        return await self._load_report_template(template_id)
-
-    async def delete_report_template(
-        self,
-        template_id: str,
-        user_id: str | None = None,
-    ) -> bool:
-        template = await self.get_report_template(template_id)
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            await conn.delete(f"{REPORT_TEMPLATE_PREFIX}:{template_id}")
-            if template and template.owner_id:
-                await conn.srem(f"user_report_templates:{template.owner_id}", template_id)
-            if user_id:
-                await conn.srem(f"user_report_templates:{user_id}", template_id)
-        return template is not None
-
-    async def get_business_intelligence_report(
-        self,
-        scope: AnalyticsScope = AnalyticsScope.ORGANIZATION,
-    ) -> BusinessIntelligenceReport:
-        try:
-            now_utc = datetime.now(UTC)
-            now = now_utc.replace(tzinfo=None)
-            week_start = now - timedelta(days=7)
-            prev_week_start = now - timedelta(days=14)
-
-            snapshot = await self._get_memory_activity_snapshot(
-                day_cutoff=now,
-                week_cutoff=week_start,
-                prev_week_start=prev_week_start,
-            )
-            total_memories = snapshot["total_memories"]
-            total_users = snapshot["unique_users"]
-            memories_this_week = snapshot["memories_last_week"]
-            memories_prev_week = snapshot["memories_prev_week"]
-
-            growth_pct = 0.0
-            if memories_prev_week:
-                growth_pct = ((memories_this_week / memories_prev_week) - 1.0) * 100.0
-
-            avg_memories_per_user = total_memories / total_users if total_users else 0.0
-
-            engagement_score = min(100.0, avg_memories_per_user * 15.0)
-            adoption_rate = min(100.0, (memories_this_week / max(total_users * 5, 1)) * 100.0)
-
-            kpis = [
-                BusinessKPI(
-                    name="Memory Growth (7d)",
-                    value=float(memories_this_week),
-                    unit="memories",
-                    change_percentage=growth_pct,
-                    trend=TrendDirection.UP if growth_pct >= 0 else TrendDirection.DOWN,
-                    status="good" if growth_pct >= 0 else "warning",
-                ),
-                BusinessKPI(
-                    name="Active Users",
-                    value=float(total_users),
-                    unit="users",
-                    change_percentage=None,
-                    trend=TrendDirection.STABLE,
-                    status="good" if total_users > 0 else "warning",
-                ),
-                BusinessKPI(
-                    name="Adoption Rate",
-                    value=round(adoption_rate, 2),
-                    unit="%",
-                    change_percentage=None,
-                    trend=TrendDirection.UP if adoption_rate >= 60 else TrendDirection.FLUCTUATING,
-                    status="good" if adoption_rate >= 60 else "warning",
-                ),
-                BusinessKPI(
-                    name="Engagement Score",
-                    value=round(engagement_score, 2),
-                    unit="score",
-                    change_percentage=None,
-                    trend=TrendDirection.UP
-                    if engagement_score >= 65
-                    else TrendDirection.FLUCTUATING,
-                    status="good" if engagement_score >= 65 else "warning",
-                    metadata={"avg_memories_per_user": avg_memories_per_user},
-                ),
-            ]
-
-            insights = await self._generate_business_insights(
-                growth_pct=growth_pct,
-                adoption_rate=adoption_rate,
-                engagement_score=engagement_score,
-                total_users=total_users,
-                memories_this_week=memories_this_week,
-            )
-
-            summary = {
-                "total_memories": total_memories,
-                "memories_this_week": memories_this_week,
-                "memories_prev_week": memories_prev_week,
-                "average_memories_per_user": round(avg_memories_per_user, 2),
-                "engagement_score": round(engagement_score, 2),
-            }
-
-            return BusinessIntelligenceReport(
-                scope=scope,
-                kpis=kpis,
-                insights=insights,
-                summary=summary,
-            )
-
-        except Exception as exc:
-            logger.exception(f"Error building BI report: {exc}")
-            raise
-
-    async def generate_report_from_template(
-        self,
-        template: ReportTemplate,
-        overrides: ReportTemplateGenerateRequest,
-    ) -> AnalyticsReport:
-        days = overrides.time_range_days or template.default_time_range_days
-        end_time = datetime.now(UTC)
-        start_time = end_time - timedelta(days=days)
-
-        filters = dict(template.filters)
-        if overrides.filters:
-            filters.update(overrides.filters)
-
-        include_forecasts = (
-            overrides.include_forecasts
-            if overrides.include_forecasts is not None
-            else template.include_forecasts
-        )
-        include_insights = (
-            overrides.include_insights
-            if overrides.include_insights is not None
-            else template.include_insights
-        )
-
-        target_user = overrides.user_id or template.owner_id
-        request = AnalyticsRequest(
-            metric_names=template.metric_names,
-            time_range={"start": start_time, "end": end_time},
-            granularity=template.granularity,
-            scope=template.scope,
-            user_id=target_user,
-            filters=filters,
-            include_forecasts=include_forecasts,
-            include_insights=include_insights,
-            metadata={
-                **template.metadata,
-                **overrides.metadata,
-                "template_id": str(template.template_id),
-                "template_name": template.name,
-            },
-        )
-
-        return await self.generate_report(request)
-
-    async def get_external_overview(self) -> dict[str, Any]:
-        now = datetime.now(UTC)
-        now_naive = now.replace(tzinfo=None)
-        day_ago = now_naive - timedelta(days=1)
-        week_ago = now_naive - timedelta(days=7)
-
-        snapshot = await self._get_memory_activity_snapshot(
-            day_cutoff=day_ago,
-            week_cutoff=week_ago,
-        )
-
-        active_users = await self._count_active_users()
-
-        top_categories = await self._run_in_session(
-            lambda session: (
-                session.query(MemoryRecord.category, func.count(MemoryRecord.memory_id))
-                .group_by(MemoryRecord.category)
-                .order_by(func.count(MemoryRecord.memory_id).desc())
-                .limit(5)
-                .all()
-            )
-        )
-
-        category_breakdown = [
-            {"category": category or "uncategorized", "count": count}
-            for category, count in top_categories
-        ]
-
-        return {
-            "generated_at": now.isoformat(),
-            "totals": {
-                "memories": snapshot["total_memories"],
-                "memories_last_24h": snapshot["memories_last_day"],
-                "memories_last_7d": snapshot["memories_last_week"],
-                "active_users": active_users,
-                "unique_users": snapshot["unique_users"],
-            },
-            "top_categories": category_breakdown,
-        }
-
-    async def get_external_metrics(self, metric_names: list[str]) -> dict[str, Any]:
-        payload: dict[str, Any] = {}
-        normalized = [name.lower() for name in metric_names]
-
-        if not normalized or "realtime" in normalized:
-            realtime = await self.get_real_time_metrics()
-            payload["realtime"] = realtime.model_dump()
-
-        if not normalized or "business" in normalized or "kpi" in normalized:
-            bi_report = await self.get_business_intelligence_report(
-                scope=AnalyticsScope.ORGANIZATION
-            )
-            payload["business"] = bi_report.model_dump(mode="json")
-
-        overview = await self.get_external_overview()
-        payload.setdefault("overview", overview)
-
-        return payload
-
-    async def list_alerts(
-        self,
-        limit: int = 20,
-        severity: AlertSeverity | None = None,
-    ) -> list[AnalyticsAlert]:
-        try:
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                raw_alerts = await conn.lrange(ALERT_LIST_KEY, 0, max(0, limit - 1))
-        except Exception as exc:
-            logger.debug("Failed to read alerts from Redis: %s", exc)
-            return []
-
-        alerts: list[AnalyticsAlert] = []
-        for raw in raw_alerts or []:
-            if isinstance(raw, bytes):
-                raw = raw.decode("utf-8")
-            try:
-                payload = json.loads(raw)
-                alert = AnalyticsAlert(**payload)
-            except Exception:
-                continue
-            if severity and alert.severity != severity:
-                continue
-            alerts.append(alert)
-        return alerts
-
-    async def get_real_time_metrics(self) -> RealTimeMetrics:
-        """Get real-time system metrics."""
-        try:
-            real_time_data = await self._get_real_time_data()
-            metrics = RealTimeMetrics(
-                active_users=real_time_data["active_users"],
-                concurrent_searches=real_time_data["concurrent_searches"],
-                memory_creation_rate=real_time_data["memory_creation_rate"],
-                search_rate=real_time_data["search_rate"],
-                avg_response_time=real_time_data["avg_response_time"],
-                error_rate=real_time_data["error_rate"],
-                system_load=real_time_data["system_load"],
-                database_connections=real_time_data["db_connections"],
-                cache_performance=real_time_data["cache_performance"],
-                queue_depth=real_time_data["queue_depth"],
-                metadata=real_time_data.get("metadata", {}),
-            )
-
-            alerts = await self._process_anomaly_detection(metrics)
-            if alerts:
-                metrics.metadata.setdefault("active_alerts", [])
-                metrics.metadata["active_alerts"] = [
-                    {
-                        "alert_id": str(alert.alert_id),
-                        "severity": alert.severity.value,
-                        "title": alert.title,
-                    }
-                    for alert in alerts
-                ]
-
-            return metrics
-
-        except Exception as e:
-            logger.exception(f"Error getting real-time metrics: {str(e)}")
-            raise
-
-    async def generate_report(self, request: AnalyticsRequest) -> AnalyticsReport:
-        """Generate comprehensive analytics report."""
-        try:
-            report_id = uuid.uuid4()
-
-            # Generate individual analytics sections based on requested metrics
-            user_metrics = None
-            content_analytics = None
-            search_analytics = None
-            collaboration_analytics = None
-            performance_analytics = None
-
-            if "user_activity" in request.metric_names:
-                user_metrics = await self.get_user_activity_metrics(
-                    request.user_id,
-                    int((request.time_range["end"] - request.time_range["start"]).days),
-                )
-
-            if "content_analytics" in request.metric_names:
-                content_analytics = await self.get_memory_content_analytics(
-                    request.user_id, request.scope
-                )
-
-            if "search_analytics" in request.metric_names:
-                search_analytics = await self.get_search_analytics(request.user_id, request.scope)
-
-            if "collaboration" in request.metric_names:
-                collaboration_analytics = await self.get_collaboration_analytics(
-                    request.user_id, request.scope
-                )
-
-            if "performance" in request.metric_names:
-                performance_analytics = await self.get_performance_analytics()
-
-            # Generate insights if requested
-            generated_insights = []
-            if request.include_insights:
-                generated_insights = await self.generate_insights(request.user_id, request.scope)
-
-            # Generate trend analyses for key metrics
-            trend_analyses = []
-            if request.include_forecasts:
-                for metric in request.metric_names[:3]:  # Limit to top 3 metrics
-                    try:
-                        trend = await self.get_trend_analysis(
-                            metric,
-                            int((request.time_range["end"] - request.time_range["start"]).days),
-                            request.granularity,
-                        )
-                        trend_analyses.append(trend)
-                    except:
-                        pass  # Skip metrics that don't have trend data
-
-            # Generate charts based on available analytics data
-            charts = []
-
-            return AnalyticsReport(
-                report_id=report_id,
-                title=f"Analytics Report - {request.scope.value}",
-                description=f"Comprehensive analytics report for {request.scope.value} scope",
-                time_period=request.time_range,
-                scope=request.scope,
-                user_id=uuid.UUID(request.user_id) if request.user_id else None,
-                user_metrics=user_metrics,
-                content_analytics=content_analytics,
-                search_analytics=search_analytics,
-                collaboration_analytics=collaboration_analytics,
-                performance_analytics=performance_analytics,
-                generated_insights=generated_insights,
-                trend_analyses=trend_analyses,
-                charts=charts,
-                generated_by="analytics_service",
-            )
-
-        except Exception as e:
-            logger.exception(f"Error generating report: {str(e)}")
-            raise
-
-    # Helper methods for data collection and processing
-
-    async def _get_user_search_metrics(self, user_id: str, time_range_days: int) -> dict[str, Any]:
-        """Get user-specific search metrics from Redis logs."""
-        cutoff_date = datetime.now(UTC).replace(tzinfo=None) - timedelta(days=time_range_days)
-
-        def _query(session: Session) -> dict[str, Any]:
-            base = session.query(SearchQuery).filter(SearchQuery.created_at >= cutoff_date)
-            if user_id:
-                base = base.filter(SearchQuery.user_id == user_id)
-
-            total = base.count()
-            avg_results = (
-                session.query(func.avg(SearchQuery.results_count))
-                .select_from(SearchQuery)
-                .filter(SearchQuery.created_at >= cutoff_date)
-                .filter(SearchQuery.user_id == user_id)
-                .scalar()
-                or 0.0
-            )
-            no_results = base.filter(SearchQuery.results_count == 0).count()
-            success_rate = (total - no_results) / total if total else 0.0
-            return {
-                "total_searches": total,
-                "avg_results": float(avg_results),
-                "success_rate": success_rate,
-                "no_result_queries": no_results,
-            }
-
-        return await self._run_in_session(_query)
-
-    async def _get_user_collaboration_metrics(
-        self, user_id: str, time_range_days: int
-    ) -> dict[str, Any]:
-        """Get user-specific collaboration metrics."""
-        cutoff_date = datetime.now(UTC).replace(tzinfo=None) - timedelta(days=time_range_days)
-
-        def _query(session: Session) -> dict[str, Any]:
-            shared_query = session.query(MemoryRecord).filter(
-                and_(
-                    MemoryRecord.created_at >= cutoff_date,
-                    MemoryRecord.user_id == user_id,
-                    MemoryRecord.team_id.isnot(None),
-                )
-            )
-            shared_memories = shared_query.count()
-            collaboration_count = (
-                session.query(MemoryRecord.team_id)
-                .filter(
-                    and_(
-                        MemoryRecord.created_at >= cutoff_date,
-                        MemoryRecord.user_id == user_id,
-                        MemoryRecord.team_id.isnot(None),
-                    )
-                )
-                .distinct()
-                .count()
-            )
-            export_count = (
-                session.query(ExportImportJob)
-                .filter(
-                    and_(
-                        ExportImportJob.user_id == user_id,
-                        ExportImportJob.job_type == "export",
-                        ExportImportJob.created_at >= cutoff_date,
-                    )
-                )
-                .count()
-            )
-            import_count = (
-                session.query(ExportImportJob)
-                .filter(
-                    and_(
-                        ExportImportJob.user_id == user_id,
-                        ExportImportJob.job_type == "import",
-                        ExportImportJob.created_at >= cutoff_date,
-                    )
-                )
-                .count()
-            )
-            return {
-                "shared_memories": shared_memories,
-                "collaboration_count": collaboration_count,
-                "export_count": export_count,
-                "import_count": import_count,
-            }
-
-        return await self._run_in_session(_query)
-
-    async def _calculate_activity_streak(self, user_id: str) -> int:
-        """Calculate current activity streak for a user."""
-
-        def _query(session: Session) -> list[datetime]:
-            rows = (
-                session.query(func.date(MemoryRecord.created_at))
-                .filter(MemoryRecord.user_id == user_id)
-                .distinct()
-                .order_by(desc(func.date(MemoryRecord.created_at)))
-                .all()
-            )
-            return [row[0] for row in rows]
-
-        dates = await self._run_in_session(_query)
-        if not dates:
-            return 0
-        streak = 0
-        current = datetime.now(UTC).date()
-        for date_val in dates:
-            if date_val == current:
-                streak += 1
-                current = current - timedelta(days=1)
-            elif date_val == current - timedelta(days=1):
-                streak += 1
-                current = date_val - timedelta(days=1)
-            else:
-                break
-        return streak
-
-    async def _calculate_content_growth_metrics(
-        self, _memories: list[MemoryRecord] | None = None
-    ) -> dict[str, float]:
-        """Calculate content growth metrics."""
-        now = datetime.now(UTC).replace(tzinfo=None)
-        week_start = now - timedelta(days=7)
-        prev_week_start = now - timedelta(days=14)
-        month_start = now - timedelta(days=30)
-        prev_month_start = now - timedelta(days=60)
-
-        def _count_between(session: Session, start: datetime, end: datetime) -> int:
-            return (
-                session.query(MemoryRecord)
-                .filter(and_(MemoryRecord.created_at >= start, MemoryRecord.created_at < end))
-                .count()
-            )
-
-        def _query(session: Session) -> dict[str, float]:
-            week_count = _count_between(session, week_start, now)
-            prev_week_count = _count_between(session, prev_week_start, week_start)
-            month_count = _count_between(session, month_start, now)
-            prev_month_count = _count_between(session, prev_month_start, month_start)
-
-            weekly_growth = (
-                ((week_count - prev_week_count) / prev_week_count) * 100 if prev_week_count else 0.0
-            )
-            monthly_growth = (
-                ((month_count - prev_month_count) / prev_month_count) * 100
-                if prev_month_count
-                else 0.0
-            )
-            daily_average = month_count / 30 if month_count else 0.0
-            return {
-                "monthly_growth_rate": monthly_growth,
-                "weekly_growth_rate": weekly_growth,
-                "daily_average": daily_average,
-            }
-
-        return await self._run_in_session(_query)
-
-    async def _get_search_log_data(
-        self, user_id: str | None, scope: AnalyticsScope, time_range_days: int
-    ) -> dict[str, Any]:
-        """Get search log data for analytics."""
-        cutoff_date = datetime.now(UTC).replace(tzinfo=None) - timedelta(days=time_range_days)
-
-        def _query(session: Session) -> dict[str, Any]:
-            base = session.query(SearchQuery).filter(SearchQuery.created_at >= cutoff_date)
-            if scope == AnalyticsScope.USER and user_id:
-                base = base.filter(SearchQuery.user_id == user_id)
-
-            total = base.count()
-            avg_results = base.with_entities(func.avg(SearchQuery.results_count)).scalar() or 0.0
-            no_results = base.filter(SearchQuery.results_count == 0).count()
-            success_rate = (total - no_results) / total if total else 0.0
-
-            term_counts = (
-                base.with_entities(SearchQuery.query, func.count(SearchQuery.id))
-                .group_by(SearchQuery.query)
-                .order_by(desc(func.count(SearchQuery.id)))
-                .limit(10)
-                .all()
-            )
-            popular_terms = [{"term": term, "count": int(count)} for term, count in term_counts]
-
-            unique_terms = [term for term, _ in term_counts]
-
-            algorithm_rows = (
-                base.with_entities(SearchQuery.search_type, func.count(SearchQuery.id))
-                .group_by(SearchQuery.search_type)
-                .all()
-            )
-            algorithm_usage = {(row[0] or "unknown"): int(row[1] or 0) for row in algorithm_rows}
-
-            filter_usage: dict[str, int] = defaultdict(int)
-            filter_rows = base.with_entities(SearchQuery.filters).all()
-            for (filters,) in filter_rows:
-                payload = filters or {}
-                if isinstance(payload, str):
-                    try:
-                        payload = json.loads(payload)
-                    except Exception:
-                        payload = {}
-                if isinstance(payload, dict):
-                    for key in payload:
-                        filter_usage[str(key)] += 1
-
-            daily_rows = (
-                base.with_entities(
-                    func.date_trunc("day", SearchQuery.created_at).label("day"),
-                    func.count(SearchQuery.id).label("count"),
-                )
-                .group_by("day")
-                .order_by("day")
-                .all()
-            )
-            daily_trends = [
-                {"date": row.day.date().isoformat(), "count": int(row.count)} for row in daily_rows
-            ]
-
-            query_lengths = [len((term or "").split()) for term in unique_terms if term]
-            query_patterns = []
-            if query_lengths:
-                avg_terms = statistics.mean(query_lengths)
-                if avg_terms <= 1.5:
-                    query_patterns.append("Single-word queries dominate")
-                elif avg_terms <= 3:
-                    query_patterns.append("Short phrase queries are common")
-                else:
-                    query_patterns.append("Long-form queries are common")
-
-            weekday_counts = defaultdict(int)
-            for row in daily_rows:
-                weekday_counts[row.day.weekday()] += int(row.count)
-            weekday_avg = {
-                str(day): int(count)
-                for day, count in sorted(weekday_counts.items(), key=lambda x: x[0])
-            }
-            seasonal_trends = {"weekday_activity": weekday_avg}
-
-            return {
-                "total_searches": total,
-                "unique_terms": unique_terms,
-                "avg_results": float(avg_results),
-                "success_rate": success_rate,
-                "no_result_queries": no_results,
-                "popular_terms": popular_terms,
-                "daily_trends": daily_trends,
-                "avg_duration_ms": 0.0,
-                "algorithm_usage": algorithm_usage,
-                "filter_usage": dict(filter_usage),
-                "query_patterns": query_patterns,
-                "seasonal_trends": seasonal_trends,
-            }
-
-        return await self._run_in_session(_query)
-
-    async def _get_collaboration_log_data(
-        self, user_id: str | None, scope: AnalyticsScope, time_range_days: int
-    ) -> dict[str, Any]:
-        """Get collaboration log data for analytics."""
-        cutoff_date = datetime.now(UTC).replace(tzinfo=None) - timedelta(days=time_range_days)
-
-        def _query(session: Session) -> dict[str, Any]:
-            base = session.query(MemoryRecord).filter(
-                and_(
-                    MemoryRecord.created_at >= cutoff_date,
-                    MemoryRecord.team_id.isnot(None),
-                )
-            )
-            if scope == AnalyticsScope.USER and user_id:
-                base = base.filter(MemoryRecord.user_id == user_id)
-
-            total_shares = base.count()
-            unique_teams_shared = base.with_entities(MemoryRecord.team_id).distinct().count()
-            unique_users_shared = base.with_entities(MemoryRecord.user_id).distinct().count()
-            collaboration_sessions = base.with_entities(MemoryRecord.session_id).distinct().count()
-            top_rows = (
-                base.order_by(desc(MemoryRecord.created_at)).limit(5).all() if total_shares else []
-            )
-            top_memories = [
-                {
-                    "memory_id": row.memory_id,
-                    "title": (row.metadata_dict.get("title") if row.metadata_dict else None)
-                    or row.memory_id,
-                    "collaboration_count": 1,
-                }
-                for row in top_rows
-            ]
-
-            success_rate = 1.0 if total_shares else 0.0
-
-            return {
-                "total_shares": total_shares,
-                "unique_users_shared": unique_users_shared,
-                "unique_teams_shared": unique_teams_shared,
-                "public_shares": 0,
-                "collaboration_sessions": collaboration_sessions,
-                "max_concurrent": 0,
-                "avg_duration_minutes": 0.0,
-                "top_memories": top_memories,
-                "success_rate": success_rate,
-                "permission_changes": 0,
-                "external_collaborations": 0,
-            }
-
-        return await self._run_in_session(_query)
-
-    async def _get_performance_metrics(self) -> dict[str, Any]:
-        """Get system performance metrics."""
-        health_service = HealthCheckService()
-        health_report = await health_service.check_all_layers()
-        layers = health_report.get("layers", {})
-        perf = health_report.get("performance", {})
-        system = perf.get("system", {})
-        service = perf.get("service", {})
-
-        cache_metrics = self._safe_cache_metrics(layers.get("cache", {}))
-        cache_hits = cache_metrics.get("search_cache_hits", 0)
-        cache_misses = cache_metrics.get("search_cache_misses", 0)
-        cache_hit_rate = (
-            cache_hits / (cache_hits + cache_misses) if (cache_hits + cache_misses) > 0 else 0.0
-        )
-
-        mem0_latency = layers.get("mem0ai", {}).get("api_latency_ms") or 0.0
-        avg_response_time = mem0_latency
-        p95_response_time = mem0_latency
-        p99_response_time = mem0_latency
-
-        reqs_per_min = service.get("requests_per_minute", 0) or 0
-        requests_per_second = reqs_per_min / 60 if reqs_per_min else 0.0
-        concurrent_users = int(service.get("active_connections") or 0)
-
-        postgres_layer = layers.get("postgres", {})
-        pool_info = postgres_layer.get("connection_pool", {})
-        pool_size = pool_info.get("size") or 0
-        checked_out = pool_info.get("checked_out") or 0
-        pool_usage = (checked_out / pool_size) if pool_size else 0.0
-
-        database_performance = {
-            "avg_query_time_ms": float(postgres_layer.get("latency_ms") or 0.0),
-            "connection_pool_usage": pool_usage,
-            "slow_queries_per_minute": 0.0,
-        }
-        api_performance = {
-            "memory_creation_ms": avg_response_time,
-            "search_query_ms": avg_response_time,
-            "export_operation_ms": 0.0,
-            "import_operation_ms": 0.0,
-        }
-
-        mem_percent = float(system.get("memory_percent") or 0.0)
-        mem_available_gb = float(system.get("memory_available_gb") or 0.0)
-        mem_total_gb = (
-            mem_available_gb / (1 - mem_percent / 100.0)
-            if mem_percent and mem_percent < 100
-            else mem_available_gb
-        )
-        mem_used_gb = max(mem_total_gb - mem_available_gb, 0.0)
-        memory_usage = {
-            "used_mb": mem_used_gb * 1024,
-            "available_mb": mem_available_gb * 1024,
-            "usage_percentage": mem_percent,
-        }
-        cpu_usage = {
-            "current_usage": float(system.get("cpu_percent") or 0.0),
-            "average_load": float(system.get("cpu_percent") or 0.0),
-            "peak_usage": float(system.get("cpu_percent") or 0.0),
-        }
-        disk_percent = float(system.get("disk_percent") or 0.0)
-        disk_free_gb = float(system.get("disk_free_gb") or 0.0)
-        disk_total_gb = (
-            disk_free_gb / (1 - disk_percent / 100.0)
-            if disk_percent and disk_percent < 100
-            else disk_free_gb
-        )
-        disk_used_gb = max(disk_total_gb - disk_free_gb, 0.0)
-        storage_metrics = {
-            "total_storage_gb": disk_total_gb,
-            "used_storage_gb": disk_used_gb,
-            "growth_rate_gb_per_month": 0.0,
-        }
-
-        return {
-            "avg_response_time_ms": avg_response_time,
-            "p95_response_time_ms": p95_response_time,
-            "p99_response_time_ms": p99_response_time,
-            "error_rate": 0.0,
-            "requests_per_second": requests_per_second,
-            "concurrent_users": concurrent_users,
-            "cache_hit_rate": cache_hit_rate,
-            "cache_metrics": cache_metrics,
-            "cache_latency_ms": layers.get("redis", {}).get("latency_ms"),
-            "redis_connected_clients": layers.get("redis", {})
-            .get("databases", {})
-            .get("search_cache", {})
-            .get("connected_clients"),
-            "database_performance": database_performance,
-            "api_performance": api_performance,
-            "memory_usage": memory_usage,
-            "cpu_usage": cpu_usage,
-            "storage_metrics": storage_metrics,
-            "infra": {
-                "health": health_report,
-                "postgres_pool": pool_info,
-            },
-        }
-
-    def _safe_cache_metrics(self, cache_layer: dict[str, Any]) -> dict[str, int]:
-        return {
-            "search_cache_hits": int(cache_layer.get("search_cache_hits") or 0),
-            "search_cache_misses": int(cache_layer.get("search_cache_misses") or 0),
-            "search_cache_writes": int(cache_layer.get("search_cache_writes") or 0),
-        }
-
-    async def _get_cache_metrics_summary(self) -> dict[str, Any]:
-        try:
-            async with redis_manager.get_redis(REDIS_SEARCH_CACHE_DB) as conn:
-                raw_metrics = await conn.hgetall("search_cache:metrics") or {}
-        except Exception as exc:  # pragma: no cover - best-effort telemetry
-            logger.debug("Unable to read search cache metrics: %s", exc)
-            raw_metrics = {}
-
-        hits = int(raw_metrics.get("hits", 0))
-        misses = int(raw_metrics.get("misses", 0))
-        total = hits + misses
-        hit_rate = hits / total if total else 0.0
-
-        return {
-            "hits": hits,
-            "misses": misses,
-            "hit_rate": hit_rate,
-            "samples": total,
-        }
-
-    def _safe_user_uuid(self, user_id: str | None) -> uuid.UUID:
-        try:
-            if user_id:
-                return uuid.UUID(str(user_id))
-        except Exception:
-            pass
-        return uuid.uuid4()
-
-    async def _get_memory_activity_snapshot(
-        self,
-        *,
-        day_cutoff: datetime,
-        week_cutoff: datetime,
-        prev_week_start: datetime | None = None,
-    ) -> dict[str, int]:
-        def _query(session: Session) -> dict[str, int]:
-            columns = [
-                func.count(MemoryRecord.memory_id).label("total_memories"),
-                func.count(func.distinct(MemoryRecord.user_id)).label("unique_users"),
-                func.sum(case((MemoryRecord.created_at >= day_cutoff, 1), else_=0)).label(
-                    "memories_last_day"
-                ),
-                func.sum(case((MemoryRecord.created_at >= week_cutoff, 1), else_=0)).label(
-                    "memories_last_week"
-                ),
-            ]
-
-            if prev_week_start is not None:
-                columns.append(
-                    func.sum(
-                        case(
-                            (
-                                and_(
-                                    MemoryRecord.created_at >= prev_week_start,
-                                    MemoryRecord.created_at < week_cutoff,
-                                ),
-                                1,
-                            ),
-                            else_=0,
-                        )
-                    ).label("memories_prev_week")
-                )
-
-            stmt = select(*columns)
-            row = session.execute(stmt).mappings().one()
-            snapshot = {key: int(row.get(key) or 0) for key in row}
-            snapshot.setdefault("memories_prev_week", 0)
-            return snapshot
-
-        return await self._run_in_session(_query)
-
-    async def _generate_usage_insights(
-        self, user_id: str | None, scope: AnalyticsScope
-    ) -> list[GeneratedInsight]:
-        """Generate usage-related insights."""
-        insights: list[GeneratedInsight] = []
-        if scope != AnalyticsScope.USER or not user_id:
-            return insights
-
-        now = datetime.now(UTC).replace(tzinfo=None)
-        week_start = now - timedelta(days=7)
-        prev_week_start = now - timedelta(days=14)
-
-        def _query(session: Session) -> tuple[int, int]:
-            week_count = (
-                session.query(MemoryRecord)
-                .filter(
-                    and_(
-                        MemoryRecord.user_id == user_id,
-                        MemoryRecord.created_at >= week_start,
-                    )
-                )
-                .count()
-            )
-            prev_week_count = (
-                session.query(MemoryRecord)
-                .filter(
-                    and_(
-                        MemoryRecord.user_id == user_id,
-                        MemoryRecord.created_at >= prev_week_start,
-                        MemoryRecord.created_at < week_start,
-                    )
-                )
-                .count()
-            )
-            return week_count, prev_week_count
-
-        week_count, prev_week_count = await self._run_in_session(_query)
-        if prev_week_count:
-            growth = ((week_count - prev_week_count) / prev_week_count) * 100
-            if growth >= 10:
-                insights.append(
-                    GeneratedInsight(
-                        title="Increased Memory Creation Activity",
-                        description=(f"Memory creation is up {growth:.1f}% vs last week."),
-                        category=InsightCategory.USAGE,
-                        severity=InsightSeverity.INFO,
-                        confidence_score=0.7,
-                        supporting_metrics=["memories_created"],
-                        recommendations=[
-                            "Maintain the current capture workflow.",
-                            "Review weekly summaries for key themes.",
-                        ],
-                    )
-                )
-            elif growth <= -10:
-                insights.append(
-                    GeneratedInsight(
-                        title="Reduced Memory Creation Activity",
-                        description=(f"Memory creation is down {abs(growth):.1f}% vs last week."),
-                        category=InsightCategory.USAGE,
-                        severity=InsightSeverity.WARNING,
-                        confidence_score=0.7,
-                        supporting_metrics=["memories_created"],
-                        recommendations=[
-                            "Check for blockers in capture workflows.",
-                            "Encourage agents to log key decisions.",
-                        ],
-                    )
-                )
-
-        return insights
-
-    async def _generate_performance_insights(self) -> list[GeneratedInsight]:
-        """Generate performance-related insights."""
-        insights: list[GeneratedInsight] = []
-        perf = await self.get_performance_analytics()
-        if perf.cache_hit_rate < CACHE_HIT_WARNING:
-            insights.append(
-                GeneratedInsight(
-                    title="Cache Hit Rate Below Target",
-                    description=(f"Cache hit rate at {perf.cache_hit_rate:.1%}, below target."),
-                    category=InsightCategory.PERFORMANCE,
-                    severity=InsightSeverity.WARNING,
-                    confidence_score=0.75,
-                    supporting_metrics=["cache_hit_rate"],
-                    recommendations=[
-                        "Review cache TTL and invalidation policy.",
-                        "Increase cache warmup for common queries.",
-                    ],
-                )
-            )
-        if perf.p95_response_time > RESPONSE_TIME_WARNING_MS:
-            insights.append(
-                GeneratedInsight(
-                    title="Elevated Response Latency",
-                    description=(f"P95 latency is {perf.p95_response_time:.1f}ms."),
-                    category=InsightCategory.PERFORMANCE,
-                    severity=InsightSeverity.WARNING,
-                    confidence_score=0.7,
-                    supporting_metrics=["p95_response_time"],
-                    recommendations=[
-                        "Inspect Mem0 and database latency metrics.",
-                        "Prioritize hot-path optimizations.",
-                    ],
-                )
-            )
-        return insights
-
-    async def _generate_collaboration_insights(
-        self, user_id: str | None, scope: AnalyticsScope
-    ) -> list[GeneratedInsight]:
-        """Generate collaboration-related insights."""
-        insights: list[GeneratedInsight] = []
-        data = await self._get_collaboration_log_data(user_id, scope, 30)
-        total_shares = data.get("total_shares", 0)
-        unique_teams = data.get("unique_teams_shared", 0)
-        if total_shares > 0:
-            insights.append(
-                GeneratedInsight(
-                    title="Collaboration Activity Detected",
-                    description=(f"{total_shares} shared memories across {unique_teams} teams."),
-                    category=InsightCategory.COLLABORATION,
-                    severity=InsightSeverity.INFO,
-                    confidence_score=0.65,
-                    supporting_metrics=["total_shares", "unique_teams_shared"],
-                    recommendations=[
-                        "Review shared memories for duplication.",
-                        "Ensure permissions are scoped correctly.",
-                    ],
-                )
-            )
-        return insights
-
-    async def _generate_content_insights(
-        self, user_id: str | None, scope: AnalyticsScope
-    ) -> list[GeneratedInsight]:
-        """Generate content-related insights."""
-        insights: list[GeneratedInsight] = []
-        content = await self.get_memory_content_analytics(user_id, scope)
-        total = content.total_memories or 0
-        if total:
-            top_category = content.most_used_categories[0] if content.most_used_categories else None
-            if top_category and top_category.get("count", 0) / total > 0.6:
-                insights.append(
-                    GeneratedInsight(
-                        title="Category Concentration",
-                        description=(
-                            f"Category '{top_category.get('category')}' represents over 60% of memories."
-                        ),
-                        category=InsightCategory.CONTENT,
-                        severity=InsightSeverity.INFO,
-                        confidence_score=0.65,
-                        supporting_metrics=["category_distribution"],
-                        recommendations=[
-                            "Consider splitting large categories into sub-themes.",
-                            "Tag key memories for easier retrieval.",
-                        ],
-                    )
-                )
-        return insights
-
-    async def _get_historical_metric_data(
-        self, metric_name: str, time_range_days: int, granularity: TimeGranularity
-    ) -> list[UsageTrend]:
-        """Get historical data for trend analysis."""
-        metric_key = metric_name.lower().strip()
-        cutoff_date = datetime.now(UTC).replace(tzinfo=None) - timedelta(days=time_range_days)
-
-        def _bucket_expr():
-            if granularity == TimeGranularity.HOURLY:
-                return func.date_trunc("hour", MemoryRecord.created_at)
-            if granularity == TimeGranularity.WEEKLY:
-                return func.date_trunc("week", MemoryRecord.created_at)
-            if granularity == TimeGranularity.MONTHLY:
-                return func.date_trunc("month", MemoryRecord.created_at)
-            if granularity == TimeGranularity.QUARTERLY:
-                return func.date_trunc("quarter", MemoryRecord.created_at)
-            if granularity == TimeGranularity.YEARLY:
-                return func.date_trunc("year", MemoryRecord.created_at)
-            return func.date_trunc("day", MemoryRecord.created_at)
-
-        def _query(session: Session) -> list[tuple[datetime, int]]:
-            if metric_key in {"memories_created", "memory_created", "memories"}:
-                bucket = _bucket_expr()
-                rows = (
-                    session.query(bucket.label("bucket"), func.count(MemoryRecord.memory_id))
-                    .filter(MemoryRecord.created_at >= cutoff_date)
-                    .group_by("bucket")
-                    .order_by("bucket")
-                    .all()
-                )
-                return [(row[0], int(row[1])) for row in rows]
-            if metric_key in {"searches", "search_queries"}:
-                bucket = func.date_trunc(
-                    "day" if granularity == TimeGranularity.DAILY else "week",
-                    SearchQuery.created_at,
-                )
-                rows = (
-                    session.query(bucket.label("bucket"), func.count(SearchQuery.id))
-                    .filter(SearchQuery.created_at >= cutoff_date)
-                    .group_by("bucket")
-                    .order_by("bucket")
-                    .all()
-                )
-                return [(row[0], int(row[1])) for row in rows]
-            return []
-
-        rows = await self._run_in_session(_query)
-        trend_points: list[UsageTrend] = []
-        previous_value: float | None = None
-        for bucket, value in rows:
-            change_percentage = (
-                ((value - previous_value) / previous_value) * 100 if previous_value else 0.0
-            )
-            trend_points.append(
-                UsageTrend(
-                    timestamp=bucket.replace(tzinfo=UTC)
-                    if bucket and bucket.tzinfo is None
-                    else bucket,
-                    value=value,
-                    metric_name=metric_name,
-                    granularity=granularity,
-                    comparison_value=previous_value if previous_value is not None else value,
-                    change_percentage=change_percentage,
-                )
-            )
-            previous_value = float(value)
-
-        return trend_points
-
-    def _calculate_linear_regression_slope(
-        self, x_values: list[float], y_values: list[float]
-    ) -> float:
-        """Calculate slope for linear regression."""
-        if len(x_values) != len(y_values) or len(x_values) < 2:
-            return 0.0
-
-        n = len(x_values)
-        sum_x = sum(x_values)
-        sum_y = sum(y_values)
-        sum_xy = sum(x * y for x, y in zip(x_values, y_values, strict=False))
-        sum_x2 = sum(x * x for x in x_values)
-
-        if n * sum_x2 - sum_x * sum_x == 0:
-            return 0.0
-
-        slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x * sum_x)
-        return slope
-
-    async def _detect_seasonal_pattern(self, trend_points: list[UsageTrend]) -> bool:
-        """Detect if there's a seasonal pattern in the data."""
-        # Simplified seasonal pattern detection
-        if len(trend_points) < 14:  # Need at least 2 weeks
-            return False
-
-        # Check for weekly patterns
-        weekly_patterns = defaultdict(list)
-        for point in trend_points:
-            day_of_week = point.timestamp.weekday()
-            weekly_patterns[day_of_week].append(point.value)
-
-        # Check if certain days consistently have higher values
-        day_averages = {}
-        for day, values in weekly_patterns.items():
-            if len(values) >= 2:
-                day_averages[day] = statistics.mean(values)
-
-        if len(day_averages) >= 3:
-            max_avg = max(day_averages.values())
-            min_avg = min(day_averages.values())
-            if max_avg > min_avg * 1.2:  # 20% variation
-                return True
-
-        return False
-
-    async def _save_dashboard_configuration(self, dashboard: AnalyticsDashboard) -> None:
-        """Save dashboard configuration to Redis."""
-        try:
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                dashboard_key = f"dashboard:{dashboard.dashboard_id}"
-                dashboard_data = dashboard.model_dump(mode="json")
-                await conn.setex(
-                    dashboard_key,
-                    self.analytics_cache_ttl,
-                    json.dumps(dashboard_data),
-                )
-
-                if dashboard.user_id:
-                    user_dashboards_key = f"user_dashboards:{dashboard.user_id}"
-                    await conn.sadd(user_dashboards_key, str(dashboard.dashboard_id))
-
-        except Exception as e:
-            logger.warning(f"Failed to save dashboard configuration: {str(e)}")
-
-    async def _save_report_template(self, template: ReportTemplate) -> None:
-        try:
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                template_key = f"{REPORT_TEMPLATE_PREFIX}:{template.template_id}"
-                data = template.model_dump(mode="json")
-                await conn.setex(template_key, self.analytics_cache_ttl, json.dumps(data))
-                if template.owner_id:
-                    await conn.sadd(
-                        f"user_report_templates:{template.owner_id}",
-                        str(template.template_id),
-                    )
-        except Exception as exc:
-            logger.warning("Failed to save report template %s: %s", template.template_id, exc)
-
-    async def _load_dashboard_configuration(self, dashboard_id: str) -> AnalyticsDashboard | None:
-        try:
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                raw_data = await conn.get(f"dashboard:{dashboard_id}")
-            if not raw_data:
-                return None
-            if isinstance(raw_data, bytes):
-                raw_data = raw_data.decode("utf-8")
-            payload = json.loads(raw_data)
-            payload["dashboard_id"] = uuid.UUID(str(payload.get("dashboard_id", dashboard_id)))
-            user_value = payload.get("user_id")
-            payload["user_id"] = uuid.UUID(str(user_value)) if user_value else None
-            payload["widgets"] = [
-                self._deserialize_widget(widget) for widget in payload.get("widgets", [])
-            ]
-            payload.setdefault("layout", {"type": "grid", "columns": 12})
-            payload.setdefault("filters", {})
-            payload.setdefault("time_range", {"default_days": 30, "presets": [7, 30, 90]})
-            payload.setdefault("metadata", {})
-            return AnalyticsDashboard(**payload)
-        except Exception as exc:
-            logger.warning("Failed to load dashboard %s: %s", dashboard_id, exc)
-            return None
-
-    async def _load_report_template(self, template_id: str) -> ReportTemplate | None:
-        try:
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                raw = await conn.get(f"{REPORT_TEMPLATE_PREFIX}:{template_id}")
-            if not raw:
-                return None
-            if isinstance(raw, bytes):
-                raw = raw.decode("utf-8")
-            payload = json.loads(raw)
-            payload["template_id"] = uuid.UUID(str(payload.get("template_id", template_id)))
-            owner = payload.get("owner_id")
-            payload["owner_id"] = uuid.UUID(str(owner)) if owner else None
-            return ReportTemplate(**payload)
-        except Exception as exc:
-            logger.warning("Failed to load report template %s: %s", template_id, exc)
-            return None
-
-    async def _process_anomaly_detection(self, metrics: RealTimeMetrics) -> list[AnalyticsAlert]:
-        alerts = self._detect_anomalies_from_metrics(metrics)
-        if not alerts:
-            return []
-        await self._persist_alerts(alerts)
-        return alerts
-
-    def _detect_anomalies_from_metrics(self, metrics: RealTimeMetrics) -> list[AnalyticsAlert]:
-        alerts: list[AnalyticsAlert] = []
-
-        def make_alert(
-            title: str,
-            message: str,
-            severity: AlertSeverity,
-            metric: str,
-            threshold: float,
-            value: float,
-        ):
-            alerts.append(
-                AnalyticsAlert(
-                    alert_id=uuid.uuid4(),
-                    title=title,
-                    message=message,
-                    severity=severity,
-                    metric_name=metric,
-                    threshold_value=threshold,
-                    current_value=value,
-                    metadata={"metric": metric, "value": value},
-                )
-            )
-
-        avg_ms = metrics.avg_response_time
-        if avg_ms > RESPONSE_TIME_CRITICAL_MS:
-            make_alert(
-                "Response time spike",
-                f"Average latency {avg_ms:.1f}ms exceeded {RESPONSE_TIME_CRITICAL_MS}ms",
-                AlertSeverity.CRITICAL,
-                "avg_response_time_ms",
-                RESPONSE_TIME_CRITICAL_MS,
-                avg_ms,
-            )
-        elif avg_ms > RESPONSE_TIME_WARNING_MS:
-            make_alert(
-                "Elevated response time",
-                f"Average latency {avg_ms:.1f}ms above {RESPONSE_TIME_WARNING_MS}ms",
-                AlertSeverity.WARNING,
-                "avg_response_time_ms",
-                RESPONSE_TIME_WARNING_MS,
-                avg_ms,
-            )
-
-        err_rate = metrics.error_rate
-        if err_rate > ERROR_RATE_CRITICAL:
-            make_alert(
-                "Error rate critical",
-                f"Error rate {err_rate:.2%} exceeded {ERROR_RATE_CRITICAL:.0%}",
-                AlertSeverity.CRITICAL,
-                "error_rate",
-                ERROR_RATE_CRITICAL,
-                err_rate,
-            )
-        elif err_rate > ERROR_RATE_WARNING:
-            make_alert(
-                "Error rate warning",
-                f"Error rate {err_rate:.2%} exceeded {ERROR_RATE_WARNING:.0%}",
-                AlertSeverity.WARNING,
-                "error_rate",
-                ERROR_RATE_WARNING,
-                err_rate,
-            )
-
-        system_load = metrics.system_load
-        if system_load > SYSTEM_LOAD_CRITICAL:
-            make_alert(
-                "System load critical",
-                f"System load {system_load:.2f} exceeded {SYSTEM_LOAD_CRITICAL}",
-                AlertSeverity.CRITICAL,
-                "system_load",
-                SYSTEM_LOAD_CRITICAL,
-                system_load,
-            )
-        elif system_load > SYSTEM_LOAD_WARNING:
-            make_alert(
-                "System load warning",
-                f"System load {system_load:.2f} exceeded {SYSTEM_LOAD_WARNING}",
-                AlertSeverity.WARNING,
-                "system_load",
-                SYSTEM_LOAD_WARNING,
-                system_load,
-            )
-
-        cache_hit_rate = (metrics.cache_performance or {}).get("hit_rate")
-        if cache_hit_rate is not None and cache_hit_rate < CACHE_HIT_WARNING:
-            make_alert(
-                "Cache hit rate low",
-                f"Cache hit rate {cache_hit_rate:.2%} fell below {CACHE_HIT_WARNING:.0%}",
-                AlertSeverity.WARNING,
-                "cache_hit_rate",
-                CACHE_HIT_WARNING,
-                cache_hit_rate,
-            )
-
-        return alerts
-
-    async def _generate_business_insights(
-        self,
-        growth_pct: float,
-        adoption_rate: float,
-        engagement_score: float,
-        total_users: int,
-        memories_this_week: int,
-    ) -> list[GeneratedInsight]:
-        insights: list[GeneratedInsight] = []
-
-        if growth_pct >= 20:
-            insights.append(
-                GeneratedInsight(
-                    title="Accelerating adoption",
-                    description="Memory creation grew more than 20% week-over-week. Consider scaling enablement materials to sustain the pace.",
-                    category=InsightCategory.USAGE,
-                    severity=InsightSeverity.INFO,
-                    confidence_score=0.82,
-                    supporting_metrics=["memory_growth"],
-                )
-            )
-        elif growth_pct < 0:
-            insights.append(
-                GeneratedInsight(
-                    title="Memory creation slowdown",
-                    description="Week-over-week memory creation dipped. Review onboarding or announce new use cases to re-energize teams.",
-                    category=InsightCategory.USAGE,
-                    severity=InsightSeverity.WARNING,
-                    confidence_score=0.71,
-                    supporting_metrics=["memory_growth"],
-                )
-            )
-
-        if adoption_rate >= 70:
-            insights.append(
-                GeneratedInsight(
-                    title="Strong adoption",
-                    description="More than 70% of targeted activity happened this week. Capture testimonials from top adopters.",
-                    category=InsightCategory.BUSINESS,
-                    severity=InsightSeverity.INFO,
-                    confidence_score=0.77,
-                    supporting_metrics=["adoption_rate"],
-                )
-            )
-        elif adoption_rate < 40:
-            insights.append(
-                GeneratedInsight(
-                    title="Adoption risk",
-                    description="Adoption rate fell below 40%. Consider refresher training or in-app nudges.",
-                    category=InsightCategory.BUSINESS,
-                    severity=InsightSeverity.WARNING,
-                    confidence_score=0.74,
-                    supporting_metrics=["adoption_rate"],
-                )
-            )
-
-        if engagement_score >= 75:
-            insights.append(
-                GeneratedInsight(
-                    title="High engagement",
-                    description="Users remain highly engaged. Prioritize advanced features (analytics, automation) to upsell value.",
-                    category=InsightCategory.CONTENT,
-                    severity=InsightSeverity.INFO,
-                    confidence_score=0.69,
-                    supporting_metrics=["engagement_score"],
-                )
-            )
-        elif engagement_score < 50:
-            insights.append(
-                GeneratedInsight(
-                    title="Engagement drop-off",
-                    description="Engagement score fell under 50. Audit content quality and ensure sessions include action-oriented prompts.",
-                    category=InsightCategory.CONTENT,
-                    severity=InsightSeverity.WARNING,
-                    confidence_score=0.68,
-                    supporting_metrics=["engagement_score"],
-                )
-            )
-
-        if total_users and memories_this_week / max(total_users, 1) >= 3:
-            insights.append(
-                GeneratedInsight(
-                    title="Power users emerging",
-                    description="Average user logged 3+ memories this week. Launch an ambassador program to capture best practices.",
-                    category=InsightCategory.COLLABORATION,
-                    severity=InsightSeverity.INFO,
-                    confidence_score=0.66,
-                    supporting_metrics=["avg_memories_per_user"],
-                )
-            )
-
-        return insights
-
-    async def _persist_alerts(self, alerts: list[AnalyticsAlert]) -> None:
-        try:
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                pipe = conn.pipeline()
-                for alert in alerts:
-                    pipe.lpush(ALERT_LIST_KEY, json.dumps(alert.model_dump(mode="json")))
-                pipe.ltrim(ALERT_LIST_KEY, 0, ALERT_HISTORY_LIMIT - 1)
-                pipe.expire(ALERT_LIST_KEY, ALERT_TTL_SECONDS)
-                await pipe.execute()
-        except Exception as exc:
-            logger.debug("Failed to persist alerts: %s", exc)
-
-    def _build_dashboard_widget(self, widget_data: dict[str, Any]) -> DashboardWidget:
-        payload = dict(widget_data)
-        payload.setdefault("widget_id", f"widget-{uuid.uuid4().hex[:8]}")
-        payload.setdefault("widget_type", "metric")
-        payload.setdefault("title", "Untitled Widget")
-        payload.setdefault("position", {"x": 0, "y": 0, "width": 6, "height": 3})
-        payload["data"] = self._coerce_widget_data(payload.get("data", {}))
-        return DashboardWidget(**payload)
-
-    def _deserialize_widget(self, widget_data: dict[str, Any]) -> DashboardWidget:
-        payload = dict(widget_data)
-        payload["data"] = self._coerce_widget_data(payload.get("data", {}))
-        return DashboardWidget(**payload)
-
-    def _coerce_widget_data(self, data: Any) -> Any:
-        if isinstance(data, (MemoryMetric, ChartData)):
-            return data
-        if isinstance(data, dict):
-            for model in (MemoryMetric, ChartData):
-                try:
-                    return model(**data)
-                except Exception:
-                    continue
-        return data
-
-    async def _get_real_time_data(self) -> dict[str, Any]:
-        """Get real-time system data using Redis + Postgres metrics."""
-
-        now_ts = int(datetime.now(UTC).timestamp())
-        active_users_task = asyncio.create_task(self._count_active_users())
-        samples = await self._fetch_realtime_samples(now_ts)
-        active_users = await active_users_task
-
-        avg_response_time, error_rate = self._summarize_response_samples(
-            samples["response_samples"]
-        )
-        avg_cache_lookup, recent_cache_hit_rate = self._summarize_cache_samples(
-            samples["cache_samples"]
-        )
-
-        memory_rate = samples["memory_events"] / max(1, REALTIME_MEMORY_WINDOW_SECONDS / 60)
-        search_rate = samples["search_events"]
-        concurrent_searches = samples["concurrent_searches"]
-
-        cache_hits_total = samples["cache_hits_total"]
-        cache_misses_total = samples["cache_misses_total"]
-        total_cache_ops = cache_hits_total + cache_misses_total
-        cache_hit_rate = (
-            cache_hits_total / total_cache_ops if total_cache_ops else recent_cache_hit_rate
-        )
-        cache_miss_rate = max(0.0, 1.0 - cache_hit_rate)
-
-        queue_depth = await self._get_queue_depth()
-        db_connections = await self._get_database_connection_count()
-        system_load = self._compute_system_load(active_users, concurrent_searches)
-
-        return {
-            "active_users": active_users,
-            "concurrent_searches": concurrent_searches,
-            "memory_creation_rate": round(memory_rate, 3),
-            "search_rate": round(search_rate, 3),
-            "avg_response_time": round(avg_response_time, 2),
-            "error_rate": round(error_rate, 3),
-            "system_load": round(system_load, 3),
-            "db_connections": db_connections,
-            "cache_performance": {
-                "hit_rate": round(cache_hit_rate, 3),
-                "miss_rate": round(cache_miss_rate, 3),
-                "avg_lookup_time_ms": round(avg_cache_lookup, 2),
-            },
-            "queue_depth": queue_depth,
-            "metadata": {
-                "memory_window_s": REALTIME_MEMORY_WINDOW_SECONDS,
-                "search_window_s": REALTIME_SEARCH_WINDOW_SECONDS,
-            },
-        }
-
-    async def _fetch_realtime_samples(self, now_ts: int) -> dict[str, Any]:
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            memory_events = await conn.zcount(
-                MEMORY_EVENT_KEY,
-                now_ts - REALTIME_MEMORY_WINDOW_SECONDS,
-                now_ts,
-            )
-            search_events = await conn.zcount(
-                SEARCH_EVENT_KEY,
-                now_ts - REALTIME_SEARCH_WINDOW_SECONDS,
-                now_ts,
-            )
-            concurrent_searches = await conn.zcount(
-                SEARCH_EVENT_KEY,
-                now_ts - REALTIME_CONCURRENT_WINDOW_SECONDS,
-                now_ts,
-            )
-            response_samples = await conn.lrange(RESPONSE_SAMPLE_KEY, 0, MAX_SAMPLE_LENGTH - 1)
-            cache_samples = await conn.lrange(CACHE_SAMPLE_KEY, 0, MAX_SAMPLE_LENGTH - 1)
-            cache_hits_total = int(await conn.get("metrics:cache:hits") or 0)
-            cache_misses_total = int(await conn.get("metrics:cache:misses") or 0)
-
-        return {
-            "memory_events": memory_events,
-            "search_events": search_events,
-            "concurrent_searches": concurrent_searches,
-            "response_samples": response_samples,
-            "cache_samples": cache_samples,
-            "cache_hits_total": cache_hits_total,
-            "cache_misses_total": cache_misses_total,
-        }
-
-    def _summarize_response_samples(self, samples: list[Any]) -> tuple[float, float]:
-        now_ts = datetime.now(UTC).timestamp()
-        valid: list[dict[str, Any]] = []
-        errors = 0
-        for raw in samples:
-            data = self._decode_sample(raw)
-            if not data:
-                continue
-            if now_ts - data.get("ts", now_ts) > RESPONSE_SAMPLE_WINDOW_SECONDS:
-                continue
-            valid.append(data)
-            if data.get("status", 200) >= 500:
-                errors += 1
-
-        if not valid:
-            return 0.0, 0.0
-
-        avg_ms = sum(item.get("ms", 0.0) for item in valid) / len(valid)
-        error_rate = errors / len(valid)
-        return avg_ms, error_rate
-
-    def _summarize_cache_samples(self, samples: list[Any]) -> tuple[float, float]:
-        now_ts = datetime.now(UTC).timestamp()
-        valid: list[dict[str, Any]] = []
-        hits = 0
-        for raw in samples:
-            data = self._decode_sample(raw)
-            if not data:
-                continue
-            if now_ts - data.get("ts", now_ts) > CACHE_SAMPLE_WINDOW_SECONDS:
-                continue
-            valid.append(data)
-            if data.get("hit"):
-                hits += 1
-
-        if not valid:
-            return 0.0, 0.0
-
-        avg_lookup = sum(item.get("ms", 0.0) for item in valid) / len(valid)
-        hit_rate = hits / len(valid)
-        return avg_lookup, hit_rate
-
-    def _decode_sample(self, raw: Any) -> dict[str, Any] | None:
-        if raw is None:
-            return None
-        if isinstance(raw, bytes):
-            raw = raw.decode("utf-8")
-        if isinstance(raw, str):
-            try:
-                return json.loads(raw)
-            except json.JSONDecodeError:
-                return None
-        if isinstance(raw, dict):
-            return raw
-        return None
-
-    async def _count_active_users(self) -> int:
-        try:
-            async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-                cursor: Any = 0
-                total = 0
-                while True:
-                    cursor, keys = await conn.scan(
-                        cursor=cursor, match="session:index:user:*", count=200
-                    )
-                    total += len(keys)
-                    if int(cursor) == 0:
-                        break
-                return total
-        except Exception as exc:
-            logger.debug("Failed to count active users: %s", exc)
-            return 0
-
-    def _compute_system_load(self, active_users: int, concurrent_searches: int) -> float:
-        target_users = max(self.config.service.max_sessions_per_user * 5, 1)
-        target_concurrency = max(self.config.service.default_rate_limit // 4, 1)
-        user_load = min(1.0, active_users / target_users)
-        search_load = min(1.0, concurrent_searches / target_concurrency)
-        return min(1.0, (user_load + search_load) / 2.0)
-
-    async def _get_queue_depth(self) -> int:
-        try:
-            pending_statuses = ["pending", "processing"]
-
-            def _query(session: Session):
-                return (
-                    session.query(func.count(ExportImportJob.job_id))
-                    .filter(ExportImportJob.status.in_(pending_statuses))
-                    .scalar()
-                    or 0
-                )
-
-            result = await self._run_in_session(_query)
-            return int(result)
-        except Exception as exc:
-            logger.debug("Failed to fetch queue depth: %s", exc)
-            return 0
-
-    async def _get_database_connection_count(self) -> int:
-        try:
-            statement = text(
-                "SELECT COUNT(*) FROM pg_stat_activity WHERE datname = current_database()"
-            )
-
-            def _execute(session: Session):
-                return session.execute(statement).scalar() or 0
-
-            result = await self._run_in_session(_execute)
-            return int(result)
-        except Exception as exc:
-            logger.debug("Failed to fetch database connections: %s", exc)
-            return 0
-
-    # ============================================================================
-    # PHASE 1 ANALYTICS ENHANCEMENT (SV-1, SV-2)
-    # ============================================================================
-
-    async def overview(
-        self,
-        org_id: str,
-        time_range_days: int = 7,
-        include_previous_period: bool = True,
-    ) -> dict[str, Any]:
-        """
-        Get analytics overview dashboard (SV-1).
-
-        Provides a comprehensive overview including:
-        - Key performance metrics (total searches, unique users)
-        - Search analytics breakdown
-        - System health indicators
-        - Trend analysis vs previous period
-
-        Args:
-            org_id: Organization ID filter
-            time_range_days: Number of days to analyze (default: 7)
-            include_previous_period: Include comparison with previous period
-
-        Returns:
-            Dict with overview data and metadata
-
-        Performance: ~50ms (queries pre-aggregated MV + system health)
-        """
-        from vds_memory_orchestrator.service.database.analytics_repository import (
-            AnalyticsRepository,
-        )
-
-        end_date = datetime.now(UTC).replace(tzinfo=None)
-        start_date = end_date - timedelta(days=time_range_days)
-
-        # Calculate previous period for comparison
-        previous_start = None
-        previous_end = None
-        if include_previous_period and time_range_days > 1:
-            previous_end = start_date
-            previous_start = previous_end - timedelta(days=time_range_days)
-
-        # Use AnalyticsRepository for MV queries
-        async with AnalyticsRepository(self.db) as repo:
-            # Fetch overview metrics
-            overview_response = await repo.get_overview_metrics(
-                org_id=org_id,
-                start_date=start_date,
-                end_date=end_date,
-                previous_start_date=previous_start,
-                previous_end_date=previous_end,
-            )
-
-            # Fetch metadata (freshness, cache status)
-            metadata = await repo.get_analytics_metadata()
-
-        # Convert to dict for JSON response
-        response = {
-            "data": overview_response.model_dump(),
-            "metadata": metadata.model_dump(),
-        }
-
-        logger.info(
-            f"Generated overview for org={org_id}, "
-            f"time_range={time_range_days}d, freshness={metadata.freshness_status}"
-        )
-
-        return response
-
-    async def search_analytics(
-        self,
-        org_id: str,
-        start_date: datetime | None = None,
-        end_date: datetime | None = None,
-        time_range_days: int = 7,
-        granularity: str = "hourly",
-    ) -> dict[str, Any]:
-        """
-        Get detailed search analytics (SV-2).
-
-        Provides comprehensive search analytics including:
-        - Time-series metrics (latency, cache hit rate, searches)
-        - Breakdown by search mode (mem0, pgvector, bm25)
-        - Error rates and unique users
-        - Overall aggregates
-
-        Args:
-            org_id: Organization ID filter
-            start_date: Custom start date (overrides time_range_days)
-            end_date: Custom end date (default: now)
-            time_range_days: Number of days (default: 7, ignored if start_date provided)
-            granularity: Data granularity ('hourly' or 'daily')
-
-        Returns:
-            Dict with search analytics data and metadata
-
-        Performance: ~20ms (queries pre-aggregated MV)
-        """
-        from vds_memory_orchestrator.service.database.analytics_repository import (
-            AnalyticsRepository,
-        )
-
-        # Validate granularity
-        if granularity not in ("hourly", "daily"):
-            raise ValidationError(
-                f"Invalid granularity: {granularity}. Must be 'hourly' or 'daily'"
-            )
-
-        # Determine date range
-        if end_date is None:
-            end_date = datetime.now(UTC).replace(tzinfo=None)
-        if start_date is None:
-            start_date = end_date - timedelta(days=time_range_days)
-
-        # Use AnalyticsRepository for MV queries
-        async with AnalyticsRepository(self.db) as repo:
-            # Fetch search analytics
-            analytics_response = await repo.get_search_analytics(
-                org_id=org_id,
-                start_date=start_date,
-                end_date=end_date,
-                granularity=granularity,
-            )
-
-            # Fetch metadata
-            metadata = await repo.get_analytics_metadata()
-
-        # Convert to dict for JSON response
-        response = {
-            "data": analytics_response.model_dump(),
-            "metadata": metadata.model_dump(),
-        }
-
-        logger.info(
-            f"Generated search analytics for org={org_id}, "
-            f"granularity={granularity}, freshness={metadata.freshness_status}, "
-            f"total_searches={analytics_response.total_searches}"
-        )
-
-        return response
-
-    async def record_search(
-        self,
-        user_id: str,
-        session_id: str,
-        org_id: str,
-        query_text: str,
-        search_mode: str,
-        results_count: int,
-        latency_ms: int,
-        cache_hit: bool,
-        filter_applied: bool = False,
-        filter_metadata: dict[str, Any] | None = None,
-        error_message: str | None = None,
-        ip_address: str | None = None,
-        user_agent: str | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """
-        Record a search analytics event.
-
-        This method should be called after each search to feed the analytics pipeline.
-        Data is written to search_analytics table and feeds the materialized views.
-
-        Args:
-            user_id: User ID
-            session_id: Session ID
-            org_id: Organization ID
-            query_text: Search query text
-            search_mode: Search mode (mem0, pgvector, bm25, mem0-error)
-            results_count: Number of results returned
-            latency_ms: Query latency in milliseconds
-            cache_hit: Whether the result was cached
-            filter_applied: Whether filters were applied
-            filter_metadata: Filter metadata JSON
-            error_message: Error message if any
-            ip_address: Client IP address
-            user_agent: Client user agent
-            metadata: Additional metadata
-
-        Returns:
-            Dict with recorded event ID and confirmation
-
-        Note: This is a fire-and-forget operation. Errors are logged but not raised.
-        """
-        from vds_memory_orchestrator.service.database.analytics_repository import (
-            AnalyticsRepository,
-        )
-
-        try:
-            async with AnalyticsRepository(self.db) as repo:
-                search_event = await repo.record_search_event(
-                    user_id=user_id,
-                    session_id=session_id,
-                    org_id=org_id,
-                    query_text=query_text,
-                    search_mode=search_mode,
-                    results_count=results_count,
-                    latency_ms=latency_ms,
-                    cache_hit=cache_hit,
-                    filter_applied=filter_applied,
-                    filter_metadata=filter_metadata,
-                    error_message=error_message,
-                    ip_address=ip_address,
-                    user_agent=user_agent,
-                    metadata=metadata,
-                )
-
-            # Commit the transaction
-            if self._is_async_session:
-                await self.db.commit()
-
-            logger.debug(
-                f"Recorded search analytics: user={user_id}, mode={search_mode}, "
-                f"latency={latency_ms}ms, cache_hit={cache_hit}"
-            )
-
-            return {
-                "status": "recorded",
-                "event_id": str(search_event.id),
-                "timestamp": search_event.created_at.isoformat(),
-            }
-
-        except Exception as exc:
-            logger.exception(f"Failed to record search analytics: {exc}")
-            # Don't raise - analytics failures shouldn't break searches
-            return {
-                "status": "failed",
-                "error": str(exc),
-            }