Upd analytis

app.py

@@ -11,6 +11,7 @@ import routes.reports as _routes_report
 import routes.chats as _routes_chat
 import routes.sessions as _routes_sessions
 import routes.health as _routes_health
+import routes.analytics as _routes_analytics
 
 # Local dev
 # if __name__ == "__main__":

helpers/setup.py

@@ -11,6 +11,7 @@ from utils.api.rotator import APIKeyRotator
 from utils.ingestion.caption import BlipCaptioner
 from utils.rag.embeddings import EmbeddingClient
 from utils.rag.rag import RAGStore, ensure_indexes
+from utils.analytics import init_analytics
 
 
 # ────────────────────────────── App Setup ──────────────────────────────
@@ -49,6 +50,10 @@ try:
     logger.info("[APP] MongoDB connection successful")
     ensure_indexes(rag)
     logger.info("[APP] MongoDB indexes ensured")
+    
+    # Initialize analytics tracker
+    init_analytics(rag.client, os.getenv("MONGO_DB", "studybuddy"))
+    logger.info("[APP] Analytics tracker initialized")
 except Exception as e:
     logger.error(f"[APP] Failed to initialize MongoDB/RAG store: {str(e)}")
     logger.error(f"[APP] MONGO_URI: {os.getenv('MONGO_URI', 'Not set')}")

routes/analytics.py

@@ -0,0 +1,87 @@
+# ────────────────────────────── routes/analytics.py ──────────────────────────────
+"""
+Analytics API Routes
+
+Provides endpoints for retrieving user and global analytics data.
+"""
+
+from fastapi import HTTPException, Query
+from typing import Optional
+from helpers.setup import app, logger
+from utils.analytics import get_analytics_tracker
+from helpers.models import BaseResponse
+
+
+class AnalyticsResponse(BaseResponse):
+    """Response model for analytics data."""
+    pass
+
+
+@app.get("/analytics/user", response_model=AnalyticsResponse)
+async def get_user_analytics(
+    user_id: str = Query(..., description="User ID to get analytics for"),
+    days: int = Query(30, description="Number of days to include in analytics", ge=1, le=365)
+):
+    """Get analytics data for a specific user."""
+    try:
+        tracker = get_analytics_tracker()
+        if not tracker:
+            raise HTTPException(500, detail="Analytics tracker not initialized")
+        
+        analytics_data = await tracker.get_user_analytics(user_id, days)
+        
+        return AnalyticsResponse(
+            success=True,
+            data=analytics_data,
+            message=f"Analytics data retrieved for user {user_id}"
+        )
+        
+    except Exception as e:
+        logger.error(f"[ANALYTICS] Failed to get user analytics: {e}")
+        raise HTTPException(500, detail=f"Failed to retrieve analytics: {str(e)}")
+
+
+@app.get("/analytics/global", response_model=AnalyticsResponse)
+async def get_global_analytics(
+    days: int = Query(30, description="Number of days to include in analytics", ge=1, le=365)
+):
+    """Get global analytics data across all users."""
+    try:
+        tracker = get_analytics_tracker()
+        if not tracker:
+            raise HTTPException(500, detail="Analytics tracker not initialized")
+        
+        analytics_data = await tracker.get_global_analytics(days)
+        
+        return AnalyticsResponse(
+            success=True,
+            data=analytics_data,
+            message="Global analytics data retrieved"
+        )
+        
+    except Exception as e:
+        logger.error(f"[ANALYTICS] Failed to get global analytics: {e}")
+        raise HTTPException(500, detail=f"Failed to retrieve global analytics: {str(e)}")
+
+
+@app.post("/analytics/cleanup", response_model=AnalyticsResponse)
+async def cleanup_analytics(
+    days_to_keep: int = Query(90, description="Number of days of data to keep", ge=30, le=365)
+):
+    """Clean up old analytics data."""
+    try:
+        tracker = get_analytics_tracker()
+        if not tracker:
+            raise HTTPException(500, detail="Analytics tracker not initialized")
+        
+        deleted_count = await tracker.cleanup_old_data(days_to_keep)
+        
+        return AnalyticsResponse(
+            success=True,
+            data={"deleted_records": deleted_count},
+            message=f"Cleaned up {deleted_count} old analytics records"
+        )
+        
+    except Exception as e:
+        logger.error(f"[ANALYTICS] Failed to cleanup analytics: {e}")
+        raise HTTPException(500, detail=f"Failed to cleanup analytics: {str(e)}")

routes/chats.py

@@ -10,6 +10,7 @@ from utils.service.common import trim_text
 from .search import build_web_context
 # Removed: enhance_question_with_memory - now handled by conversation manager
 from utils.api.router import select_model, generate_answer_with_model
+from utils.analytics import get_analytics_tracker
 
 
 @app.post("/chat/save", response_model=MessageResponse)
@@ -708,6 +709,24 @@ async def _chat_impl(
         update_chat_status(session_id, "generating", "Generating answer...", 80)
     
     try:
+        # Track model usage for analytics
+        tracker = get_analytics_tracker()
+        if tracker:
+            await tracker.track_model_usage(
+                user_id=user_id,
+                model_name=selection["model"],
+                provider=selection["provider"],
+                context="chat",
+                metadata={"project_id": project_id, "session_id": session_id}
+            )
+            await tracker.track_agent_usage(
+                user_id=user_id,
+                agent_name="chat",
+                action="generate_answer",
+                context="chat",
+                metadata={"project_id": project_id, "session_id": session_id}
+            )
+        
         answer = await generate_answer_with_model(
             selection=selection,
             system_prompt=system_prompt,
@@ -888,6 +907,24 @@ async def chat_with_search(
     selection = select_model(question=question, context=doc_context)
     logger.info(f"[CHAT] Generating web-augmented answer with {selection['provider']} {selection['model']}")
     try:
+        # Track model usage for analytics
+        tracker = get_analytics_tracker()
+        if tracker:
+            await tracker.track_model_usage(
+                user_id=user_id,
+                model_name=selection["model"],
+                provider=selection["provider"],
+                context="chat_web_augmented",
+                metadata={"project_id": project_id, "session_id": session_id}
+            )
+            await tracker.track_agent_usage(
+                user_id=user_id,
+                agent_name="chat",
+                action="generate_web_augmented_answer",
+                context="chat_web_augmented",
+                metadata={"project_id": project_id, "session_id": session_id}
+            )
+        
         answer = await generate_answer_with_model(
             selection=selection,
             system_prompt=system_prompt,

routes/reports.py

@@ -10,6 +10,7 @@ from .search import build_web_context
 from helpers.models import ReportResponse, StatusUpdateResponse
 from utils.service.common import trim_text
 from utils.api.router import select_model, generate_answer_with_model
+from utils.analytics import get_analytics_tracker
 from helpers.coder import generate_code_artifacts, extract_structured_code
 from helpers.diagram import should_generate_mermaid, generate_mermaid_diagram
 
@@ -123,6 +124,18 @@ async def generate_report(
     # Step 1: Chain of Thought Planning with NVIDIA
     logger.info("[REPORT] Starting CoT planning phase")
     update_report_status(session_id, "planning", "Planning action...", 25)
+    
+    # Track report agent usage
+    tracker = get_analytics_tracker()
+    if tracker:
+        await tracker.track_agent_usage(
+            user_id=user_id,
+            agent_name="report",
+            action="generate_report",
+            context="report_generation",
+            metadata={"project_id": project_id, "session_id": session_id, "filename": filename}
+        )
+    
     # Use enhanced instructions for better CoT planning
     cot_plan = await generate_cot_plan(enhanced_instructions, file_summary, context_text, web_context_block, nvidia_rotator, gemini_rotator)
     

routes/search.py

@@ -4,6 +4,7 @@ from typing import List, Dict, Any, Tuple
 from helpers.setup import logger, embedder, gemini_rotator, nvidia_rotator
 from utils.api.router import select_model, generate_answer_with_model, qwen_chat_completion, nvidia_large_chat_completion
 from utils.service.summarizer import llama_summarize
+from utils.analytics import get_analytics_tracker
 
 
 async def extract_search_keywords(user_query: str, nvidia_rotator) -> List[str]:
@@ -28,6 +29,17 @@ Return only the keywords, separated by spaces, no other text."""
         
         user_prompt = f"User query: {user_query}\n\nExtract search keywords:"
         
+        # Track search agent usage
+        tracker = get_analytics_tracker()
+        if tracker:
+            await tracker.track_agent_usage(
+                user_id="system",  # Search is system-level
+                agent_name="search",
+                action="extract_keywords",
+                context="web_search",
+                metadata={"query": user_query}
+            )
+        
         # Use NVIDIA Large for better keyword extraction
         response = await nvidia_large_chat_completion(sys_prompt, user_prompt, nvidia_rotator)
         

static/analytics.js

@@ -0,0 +1,292 @@
+// ────────────────────────────── static/analytics.js ──────────────────────────────
+(function() {
+  // DOM elements
+  const analyticsSection = document.getElementById('analytics-section');
+  const analyticsPeriod = document.getElementById('analytics-period');
+  const refreshAnalytics = document.getElementById('refresh-analytics');
+  const modelUsageChart = document.getElementById('model-usage-chart');
+  const agentUsageChart = document.getElementById('agent-usage-chart');
+  const dailyTrendsChart = document.getElementById('daily-trends-chart');
+  const usageSummary = document.getElementById('usage-summary');
+  
+  // State
+  let currentAnalyticsData = null;
+  let isAnalyticsVisible = false;
+  
+  // Initialize
+  init();
+  
+  function init() {
+    setupEventListeners();
+    // Load analytics when section becomes visible
+    document.addEventListener('sectionChanged', (event) => {
+      if (event.detail.section === 'analytics') {
+        isAnalyticsVisible = true;
+        loadAnalytics();
+      } else {
+        isAnalyticsVisible = false;
+      }
+    });
+  }
+  
+  function setupEventListeners() {
+    // Period change
+    if (analyticsPeriod) {
+      analyticsPeriod.addEventListener('change', () => {
+        if (isAnalyticsVisible) {
+          loadAnalytics();
+        }
+      });
+    }
+    
+    // Refresh button
+    if (refreshAnalytics) {
+      refreshAnalytics.addEventListener('click', () => {
+        loadAnalytics();
+      });
+    }
+  }
+  
+  async function loadAnalytics() {
+    if (!isAnalyticsVisible) return;
+    
+    const user = window.__sb_get_user();
+    if (!user) {
+      showAnalyticsError('Please sign in to view analytics');
+      return;
+    }
+    
+    const period = analyticsPeriod ? analyticsPeriod.value : '30';
+    
+    try {
+      showAnalyticsLoading();
+      
+      const response = await fetch(`/analytics/user?user_id=${encodeURIComponent(user.user_id)}&days=${period}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      
+      const data = await response.json();
+      if (data.success) {
+        currentAnalyticsData = data.data;
+        renderAnalytics(data.data);
+      } else {
+        throw new Error(data.message || 'Failed to load analytics');
+      }
+      
+    } catch (error) {
+      console.error('Analytics loading error:', error);
+      showAnalyticsError(`Failed to load analytics: ${error.message}`);
+    }
+  }
+  
+  function showAnalyticsLoading() {
+    const loadingHtml = '<div class="loading-spinner">Loading analytics...</div>';
+    if (modelUsageChart) modelUsageChart.innerHTML = loadingHtml;
+    if (agentUsageChart) agentUsageChart.innerHTML = loadingHtml;
+    if (dailyTrendsChart) dailyTrendsChart.innerHTML = loadingHtml;
+    if (usageSummary) usageSummary.innerHTML = loadingHtml;
+  }
+  
+  function showAnalyticsError(message) {
+    const errorHtml = `<div class="analytics-error">${message}</div>`;
+    if (modelUsageChart) modelUsageChart.innerHTML = errorHtml;
+    if (agentUsageChart) agentUsageChart.innerHTML = errorHtml;
+    if (dailyTrendsChart) dailyTrendsChart.innerHTML = errorHtml;
+    if (usageSummary) usageSummary.innerHTML = errorHtml;
+  }
+  
+  function renderAnalytics(data) {
+    renderModelUsage(data.model_usage);
+    renderAgentUsage(data.agent_usage);
+    renderDailyTrends(data.daily_usage);
+    renderUsageSummary(data);
+  }
+  
+  function renderModelUsage(modelUsage) {
+    if (!modelUsageChart) return;
+    
+    if (!modelUsage || modelUsage.length === 0) {
+      modelUsageChart.innerHTML = '<div class="analytics-empty">No model usage data available</div>';
+      return;
+    }
+    
+    // Sort by usage count
+    const sortedModels = modelUsage.sort((a, b) => b.count - a.count);
+    const totalUsage = sortedModels.reduce((sum, model) => sum + model.count, 0);
+    
+    let html = '<div class="model-usage-list">';
+    sortedModels.forEach(model => {
+      const percentage = totalUsage > 0 ? Math.round((model.count / totalUsage) * 100) : 0;
+      const lastUsed = new Date(model.last_used * 1000).toLocaleDateString();
+      
+      html += `
+        <div class="model-usage-item">
+          <div class="model-info">
+            <div class="model-name">${model._id}</div>
+            <div class="model-provider">${model.provider}</div>
+          </div>
+          <div class="model-stats">
+            <div class="model-count">${model.count} requests</div>
+            <div class="model-percentage">${percentage}%</div>
+            <div class="model-last-used">Last used: ${lastUsed}</div>
+          </div>
+          <div class="model-bar">
+            <div class="model-bar-fill" style="width: ${percentage}%"></div>
+          </div>
+        </div>
+      `;
+    });
+    html += '</div>';
+    
+    modelUsageChart.innerHTML = html;
+  }
+  
+  function renderAgentUsage(agentUsage) {
+    if (!agentUsageChart) return;
+    
+    if (!agentUsage || agentUsage.length === 0) {
+      agentUsageChart.innerHTML = '<div class="analytics-empty">No agent usage data available</div>';
+      return;
+    }
+    
+    // Sort by usage count
+    const sortedAgents = agentUsage.sort((a, b) => b.count - a.count);
+    const totalUsage = sortedAgents.reduce((sum, agent) => sum + agent.count, 0);
+    
+    let html = '<div class="agent-usage-list">';
+    sortedAgents.forEach(agent => {
+      const percentage = totalUsage > 0 ? Math.round((agent.count / totalUsage) * 100) : 0;
+      const lastUsed = new Date(agent.last_used * 1000).toLocaleDateString();
+      const actions = agent.actions ? agent.actions.join(', ') : 'N/A';
+      
+      html += `
+        <div class="agent-usage-item">
+          <div class="agent-info">
+            <div class="agent-name">${agent._id}</div>
+            <div class="agent-actions">Actions: ${actions}</div>
+          </div>
+          <div class="agent-stats">
+            <div class="agent-count">${agent.count} requests</div>
+            <div class="agent-percentage">${percentage}%</div>
+            <div class="agent-last-used">Last used: ${lastUsed}</div>
+          </div>
+          <div class="agent-bar">
+            <div class="agent-bar-fill" style="width: ${percentage}%"></div>
+          </div>
+        </div>
+      `;
+    });
+    html += '</div>';
+    
+    agentUsageChart.innerHTML = html;
+  }
+  
+  function renderDailyTrends(dailyUsage) {
+    if (!dailyTrendsChart) return;
+    
+    if (!dailyUsage || dailyUsage.length === 0) {
+      dailyTrendsChart.innerHTML = '<div class="analytics-empty">No daily usage data available</div>';
+      return;
+    }
+    
+    // Sort by date
+    const sortedDaily = dailyUsage.sort((a, b) => {
+      const dateA = new Date(a._id.year, a._id.month - 1, a._id.day);
+      const dateB = new Date(b._id.year, b._id.month - 1, b._id.day);
+      return dateA - dateB;
+    });
+    
+    const maxUsage = Math.max(...sortedDaily.map(d => d.total_requests));
+    
+    let html = '<div class="daily-trends-chart">';
+    sortedDaily.forEach(day => {
+      const date = new Date(day._id.year, day._id.month - 1, day._id.day);
+      const dateStr = date.toLocaleDateString();
+      const height = maxUsage > 0 ? (day.total_requests / maxUsage) * 100 : 0;
+      
+      html += `
+        <div class="daily-bar">
+          <div class="daily-bar-fill" style="height: ${height}%"></div>
+          <div class="daily-label">${dateStr}</div>
+          <div class="daily-count">${day.total_requests}</div>
+        </div>
+      `;
+    });
+    html += '</div>';
+    
+    dailyTrendsChart.innerHTML = html;
+  }
+  
+  function renderUsageSummary(data) {
+    if (!usageSummary) return;
+    
+    const totalRequests = data.total_requests || 0;
+    const periodDays = data.period_days || 30;
+    const avgPerDay = Math.round(totalRequests / periodDays * 10) / 10;
+    
+    const modelCount = data.model_usage ? data.model_usage.length : 0;
+    const agentCount = data.agent_usage ? data.agent_usage.length : 0;
+    
+    const mostUsedModel = data.model_usage && data.model_usage.length > 0 
+      ? data.model_usage[0] 
+      : null;
+    const mostUsedAgent = data.agent_usage && data.agent_usage.length > 0 
+      ? data.agent_usage[0] 
+      : null;
+    
+    let html = `
+      <div class="usage-summary-content">
+        <div class="summary-stat">
+          <div class="summary-value">${totalRequests}</div>
+          <div class="summary-label">Total Requests</div>
+        </div>
+        <div class="summary-stat">
+          <div class="summary-value">${avgPerDay}</div>
+          <div class="summary-label">Avg per Day</div>
+        </div>
+        <div class="summary-stat">
+          <div class="summary-value">${modelCount}</div>
+          <div class="summary-label">Models Used</div>
+        </div>
+        <div class="summary-stat">
+          <div class="summary-value">${agentCount}</div>
+          <div class="summary-label">Agents Used</div>
+        </div>
+    `;
+    
+    if (mostUsedModel) {
+      html += `
+        <div class="summary-highlight">
+          <div class="highlight-label">Most Used Model:</div>
+          <div class="highlight-value">${mostUsedModel._id} (${mostUsedModel.count} times)</div>
+        </div>
+      `;
+    }
+    
+    if (mostUsedAgent) {
+      html += `
+        <div class="summary-highlight">
+          <div class="highlight-label">Most Used Agent:</div>
+          <div class="highlight-value">${mostUsedAgent._id} (${mostUsedAgent.count} times)</div>
+        </div>
+      `;
+    }
+    
+    html += '</div>';
+    usageSummary.innerHTML = html;
+  }
+  
+  // Expose functions for external use
+  window.__sb_load_analytics = loadAnalytics;
+  window.__sb_show_analytics_section = () => {
+    if (analyticsSection) {
+      analyticsSection.style.display = 'block';
+    }
+  };
+  window.__sb_hide_analytics_section = () => {
+    if (analyticsSection) {
+      analyticsSection.style.display = 'none';
+    }
+  };
+})();

static/index.html

@@ -193,6 +193,61 @@
             </div>
           </section>
 
+          <!-- Analytics Section -->
+          <section class="card reveal" id="analytics-section" style="display:none;">
+            <div class="card-header">
+              <h2>📊 Analytics Dashboard</h2>
+              <p>Track your usage of AI models and agents</p>
+            </div>
+            <div class="analytics-content">
+              <div class="analytics-controls">
+                <div class="analytics-period">
+                  <label for="analytics-period">Time Period:</label>
+                  <select id="analytics-period" class="analytics-select">
+                    <option value="7">Last 7 days</option>
+                    <option value="30" selected>Last 30 days</option>
+                    <option value="90">Last 90 days</option>
+                  </select>
+                </div>
+                <button id="refresh-analytics" class="btn-primary">Refresh Data</button>
+              </div>
+              
+              <div class="analytics-grid">
+                <!-- Model Usage -->
+                <div class="analytics-card">
+                  <h3>🤖 Model Usage</h3>
+                  <div class="analytics-chart" id="model-usage-chart">
+                    <div class="loading-spinner">Loading...</div>
+                  </div>
+                </div>
+                
+                <!-- Agent Usage -->
+                <div class="analytics-card">
+                  <h3>🔧 Agent Usage</h3>
+                  <div class="analytics-chart" id="agent-usage-chart">
+                    <div class="loading-spinner">Loading...</div>
+                  </div>
+                </div>
+                
+                <!-- Daily Trends -->
+                <div class="analytics-card analytics-wide">
+                  <h3>📈 Daily Usage Trends</h3>
+                  <div class="analytics-chart" id="daily-trends-chart">
+                    <div class="loading-spinner">Loading...</div>
+                  </div>
+                </div>
+                
+                <!-- Usage Summary -->
+                <div class="analytics-card">
+                  <h3>📋 Usage Summary</h3>
+                  <div class="analytics-summary" id="usage-summary">
+                    <div class="loading-spinner">Loading...</div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </section>
+
           <!-- Chat Section -->
           <section class="card reveal" id="chat-section">
             <div class="card-header">
@@ -380,5 +435,6 @@
   <script src="/static/projects.js"></script>
   <script src="/static/script.js"></script>
   <script src="/static/sessions.js"></script>
+  <script src="/static/analytics.js"></script>
 </body>
 </html>

static/sidebar.js

@@ -149,7 +149,10 @@
         showSection('chat');
         break;
       case 'analytics':
-        // Could show usage analytics or insights
+        showSection('analytics');
+        if (window.__sb_load_analytics) {
+          window.__sb_load_analytics();
+        }
         break;
       case 'settings':
         // Could show user settings or preferences
@@ -166,14 +169,33 @@
     const upload = document.getElementById('upload-section');
     const chat = document.getElementById('chat-section');
     const files = document.getElementById('files-section');
+    const analytics = document.getElementById('analytics-section');
+    
     if (!upload || !chat || !files) return;
-    // Show upload section for projects, files section for files, chat section for chat
-    upload.style.display = name === 'upload' ? 'block' : 'none';
-    chat.style.display = name === 'chat' ? 'block' : 'none';
-    files.style.display = name === 'files' ? 'block' : 'none';
-    // Enable chat functionality when chat section is visible
-    if (name === 'chat' && window.__sb_enable_chat) {
-      window.__sb_enable_chat();
+    
+    // Hide all sections first
+    upload.style.display = 'none';
+    chat.style.display = 'none';
+    files.style.display = 'none';
+    if (analytics) analytics.style.display = 'none';
+    
+    // Show selected section
+    switch (name) {
+      case 'upload':
+        upload.style.display = 'block';
+        break;
+      case 'chat':
+        chat.style.display = 'block';
+        if (window.__sb_enable_chat) {
+          window.__sb_enable_chat();
+        }
+        break;
+      case 'files':
+        files.style.display = 'block';
+        break;
+      case 'analytics':
+        if (analytics) analytics.style.display = 'block';
+        break;
     }
   }
 

static/styles.css

@@ -1805,4 +1805,347 @@
   .session-actions {
     justify-content: center;
   }
+}
+
+/* Analytics Styles */
+.analytics-content {
+  padding: 1.5rem;
+}
+
+.analytics-controls {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 2rem;
+  padding: 1rem;
+  background: var(--card);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.analytics-period {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.analytics-period label {
+  font-weight: 500;
+  color: var(--text);
+}
+
+.analytics-select {
+  padding: 0.5rem 0.75rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg);
+  color: var(--text);
+  font-size: 0.875rem;
+}
+
+.analytics-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 1.5rem;
+  margin-bottom: 2rem;
+}
+
+.analytics-card {
+  background: var(--card);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+  padding: 1.5rem;
+}
+
+.analytics-card h3 {
+  margin: 0 0 1rem 0;
+  font-size: 1.125rem;
+  font-weight: 600;
+  color: var(--text);
+}
+
+.analytics-wide {
+  grid-column: 1 / -1;
+}
+
+.analytics-chart {
+  min-height: 200px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.analytics-empty {
+  text-align: center;
+  color: var(--muted);
+  font-style: italic;
+}
+
+.analytics-error {
+  text-align: center;
+  color: var(--error);
+  font-weight: 500;
+}
+
+.loading-spinner {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--muted);
+  font-size: 0.875rem;
+}
+
+/* Model Usage Styles */
+.model-usage-list {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.model-usage-item {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: 1rem;
+  background: var(--bg-secondary);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.model-info {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.model-name {
+  font-weight: 600;
+  color: var(--text);
+  font-size: 0.875rem;
+}
+
+.model-provider {
+  font-size: 0.75rem;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.model-stats {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  font-size: 0.875rem;
+}
+
+.model-count {
+  font-weight: 600;
+  color: var(--accent);
+}
+
+.model-percentage {
+  color: var(--text-secondary);
+}
+
+.model-last-used {
+  color: var(--muted);
+  font-size: 0.75rem;
+}
+
+.model-bar {
+  height: 4px;
+  background: var(--border);
+  border-radius: 2px;
+  overflow: hidden;
+}
+
+.model-bar-fill {
+  height: 100%;
+  background: var(--gradient-accent);
+  transition: width 0.3s ease;
+}
+
+/* Agent Usage Styles */
+.agent-usage-list {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.agent-usage-item {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  padding: 1rem;
+  background: var(--bg-secondary);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.agent-info {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.agent-name {
+  font-weight: 600;
+  color: var(--text);
+  font-size: 0.875rem;
+}
+
+.agent-actions {
+  font-size: 0.75rem;
+  color: var(--muted);
+}
+
+.agent-stats {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  font-size: 0.875rem;
+}
+
+.agent-count {
+  font-weight: 600;
+  color: var(--success);
+}
+
+.agent-percentage {
+  color: var(--text-secondary);
+}
+
+.agent-last-used {
+  color: var(--muted);
+  font-size: 0.75rem;
+}
+
+.agent-bar {
+  height: 4px;
+  background: var(--border);
+  border-radius: 2px;
+  overflow: hidden;
+}
+
+.agent-bar-fill {
+  height: 100%;
+  background: var(--gradient-success);
+  transition: width 0.3s ease;
+}
+
+/* Daily Trends Styles */
+.daily-trends-chart {
+  display: flex;
+  align-items: end;
+  gap: 0.5rem;
+  height: 200px;
+  padding: 1rem 0;
+}
+
+.daily-bar {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.5rem;
+  min-height: 100px;
+}
+
+.daily-bar-fill {
+  width: 100%;
+  background: var(--gradient-accent);
+  border-radius: 2px 2px 0 0;
+  min-height: 4px;
+  transition: height 0.3s ease;
+}
+
+.daily-label {
+  font-size: 0.75rem;
+  color: var(--muted);
+  text-align: center;
+  writing-mode: vertical-rl;
+  text-orientation: mixed;
+}
+
+.daily-count {
+  font-size: 0.75rem;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+/* Usage Summary Styles */
+.usage-summary-content {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 1rem;
+}
+
+.summary-stat {
+  text-align: center;
+  padding: 1rem;
+  background: var(--bg-secondary);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+}
+
+.summary-value {
+  font-size: 1.5rem;
+  font-weight: 700;
+  color: var(--accent);
+  margin-bottom: 0.25rem;
+}
+
+.summary-label {
+  font-size: 0.75rem;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.summary-highlight {
+  grid-column: 1 / -1;
+  padding: 1rem;
+  background: var(--bg-secondary);
+  border-radius: var(--radius);
+  border: 1px solid var(--border);
+  margin-top: 1rem;
+}
+
+.highlight-label {
+  font-size: 0.75rem;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  margin-bottom: 0.25rem;
+}
+
+.highlight-value {
+  font-size: 0.875rem;
+  color: var(--text);
+  font-weight: 500;
+}
+
+/* Analytics responsive */
+@media (max-width: 1024px) {
+  .analytics-grid {
+    grid-template-columns: 1fr;
+  }
+  
+  .analytics-controls {
+    flex-direction: column;
+    gap: 1rem;
+    align-items: stretch;
+  }
+  
+  .usage-summary-content {
+    grid-template-columns: 1fr;
+  }
+  
+  .daily-trends-chart {
+    gap: 0.25rem;
+  }
+  
+  .daily-label {
+    font-size: 0.625rem;
+  }
 }

utils/analytics.py

@@ -0,0 +1,232 @@
+# ────────────────────────────── utils/analytics.py ──────────────────────────────
+"""
+Analytics and Usage Tracking System
+
+Tracks user-specific usage of models and agents for analytics dashboard.
+"""
+
+import time
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Optional
+from pymongo.collection import Collection
+from pymongo.database import Database
+from pymongo import MongoClient
+from utils.logger import get_logger
+
+logger = get_logger("ANALYTICS", __name__)
+
+class AnalyticsTracker:
+    """Tracks user usage analytics for models and agents."""
+    
+    def __init__(self, mongo_client: MongoClient, db_name: str = "studybuddy"):
+        self.client = mongo_client
+        self.db = mongo_client[db_name]
+        self.usage_collection = self.db["usage_analytics"]
+        self._ensure_indexes()
+    
+    def _ensure_indexes(self):
+        """Create necessary indexes for efficient queries."""
+        try:
+            # Compound index for user_id + timestamp
+            self.usage_collection.create_index([("user_id", 1), ("timestamp", -1)])
+            # Index for aggregation queries
+            self.usage_collection.create_index([("user_id", 1), ("type", 1), ("timestamp", -1)])
+            logger.info("[ANALYTICS] Indexes created successfully")
+        except Exception as e:
+            logger.warning(f"[ANALYTICS] Failed to create indexes: {e}")
+    
+    async def track_model_usage(self, user_id: str, model_name: str, provider: str, 
+                               context: str = "", metadata: Optional[Dict] = None):
+        """Track model usage for analytics."""
+        try:
+            usage_record = {
+                "user_id": user_id,
+                "type": "model",
+                "model_name": model_name,
+                "provider": provider,
+                "context": context,
+                "timestamp": time.time(),
+                "created_at": datetime.now(timezone.utc),
+                "metadata": metadata or {}
+            }
+            
+            await self.usage_collection.insert_one(usage_record)
+            logger.debug(f"[ANALYTICS] Tracked model usage: {model_name} for user {user_id}")
+            
+        except Exception as e:
+            logger.error(f"[ANALYTICS] Failed to track model usage: {e}")
+    
+    async def track_agent_usage(self, user_id: str, agent_name: str, action: str,
+                              context: str = "", metadata: Optional[Dict] = None):
+        """Track agent usage for analytics."""
+        try:
+            usage_record = {
+                "user_id": user_id,
+                "type": "agent",
+                "agent_name": agent_name,
+                "action": action,
+                "context": context,
+                "timestamp": time.time(),
+                "created_at": datetime.now(timezone.utc),
+                "metadata": metadata or {}
+            }
+            
+            await self.usage_collection.insert_one(usage_record)
+            logger.debug(f"[ANALYTICS] Tracked agent usage: {agent_name} for user {user_id}")
+            
+        except Exception as e:
+            logger.error(f"[ANALYTICS] Failed to track agent usage: {e}")
+    
+    async def get_user_analytics(self, user_id: str, days: int = 30) -> Dict[str, Any]:
+        """Get comprehensive analytics for a user."""
+        try:
+            # Calculate time range
+            cutoff_time = time.time() - (days * 24 * 60 * 60)
+            
+            # Model usage analytics
+            model_pipeline = [
+                {"$match": {"user_id": user_id, "type": "model", "timestamp": {"$gte": cutoff_time}}},
+                {"$group": {
+                    "_id": "$model_name",
+                    "count": {"$sum": 1},
+                    "provider": {"$first": "$provider"},
+                    "last_used": {"$max": "$timestamp"}
+                }},
+                {"$sort": {"count": -1}}
+            ]
+            
+            model_usage = list(self.usage_collection.aggregate(model_pipeline))
+            
+            # Agent usage analytics
+            agent_pipeline = [
+                {"$match": {"user_id": user_id, "type": "agent", "timestamp": {"$gte": cutoff_time}}},
+                {"$group": {
+                    "_id": "$agent_name",
+                    "count": {"$sum": 1},
+                    "actions": {"$addToSet": "$action"},
+                    "last_used": {"$max": "$timestamp"}
+                }},
+                {"$sort": {"count": -1}}
+            ]
+            
+            agent_usage = list(self.usage_collection.aggregate(agent_pipeline))
+            
+            # Daily usage trends
+            daily_pipeline = [
+                {"$match": {"user_id": user_id, "timestamp": {"$gte": cutoff_time}}},
+                {"$group": {
+                    "_id": {
+                        "year": {"$year": {"$dateFromTimestamp": {"$multiply": ["$timestamp", 1000]}}},
+                        "month": {"$month": {"$dateFromTimestamp": {"$multiply": ["$timestamp", 1000]}}},
+                        "day": {"$dayOfMonth": {"$dateFromTimestamp": {"$multiply": ["$timestamp", 1000]}}}
+                    },
+                    "total_requests": {"$sum": 1},
+                    "model_requests": {"$sum": {"$cond": [{"$eq": ["$type", "model"]}, 1, 0]}},
+                    "agent_requests": {"$sum": {"$cond": [{"$eq": ["$type", "agent"]}, 1, 0]}}
+                }},
+                {"$sort": {"_id.year": 1, "_id.month": 1, "_id.day": 1}}
+            ]
+            
+            daily_usage = list(self.usage_collection.aggregate(daily_pipeline))
+            
+            return {
+                "user_id": user_id,
+                "period_days": days,
+                "model_usage": model_usage,
+                "agent_usage": agent_usage,
+                "daily_usage": daily_usage,
+                "total_requests": sum(item["count"] for item in model_usage + agent_usage),
+                "generated_at": datetime.now(timezone.utc).isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"[ANALYTICS] Failed to get user analytics: {e}")
+            return {
+                "user_id": user_id,
+                "period_days": days,
+                "model_usage": [],
+                "agent_usage": [],
+                "daily_usage": [],
+                "total_requests": 0,
+                "error": str(e),
+                "generated_at": datetime.now(timezone.utc).isoformat()
+            }
+    
+    async def get_global_analytics(self, days: int = 30) -> Dict[str, Any]:
+        """Get global analytics across all users."""
+        try:
+            cutoff_time = time.time() - (days * 24 * 60 * 60)
+            
+            # Global model usage
+            model_pipeline = [
+                {"$match": {"type": "model", "timestamp": {"$gte": cutoff_time}}},
+                {"$group": {
+                    "_id": "$model_name",
+                    "count": {"$sum": 1},
+                    "unique_users": {"$addToSet": "$user_id"},
+                    "provider": {"$first": "$provider"}
+                }},
+                {"$addFields": {"unique_user_count": {"$size": "$unique_users"}}},
+                {"$sort": {"count": -1}}
+            ]
+            
+            global_model_usage = list(self.usage_collection.aggregate(model_pipeline))
+            
+            # Global agent usage
+            agent_pipeline = [
+                {"$match": {"type": "agent", "timestamp": {"$gte": cutoff_time}}},
+                {"$group": {
+                    "_id": "$agent_name",
+                    "count": {"$sum": 1},
+                    "unique_users": {"$addToSet": "$user_id"},
+                    "actions": {"$addToSet": "$action"}
+                }},
+                {"$addFields": {"unique_user_count": {"$size": "$unique_users"}}},
+                {"$sort": {"count": -1}}
+            ]
+            
+            global_agent_usage = list(self.usage_collection.aggregate(agent_pipeline))
+            
+            return {
+                "period_days": days,
+                "global_model_usage": global_model_usage,
+                "global_agent_usage": global_agent_usage,
+                "total_requests": sum(item["count"] for item in global_model_usage + global_agent_usage),
+                "generated_at": datetime.now(timezone.utc).isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"[ANALYTICS] Failed to get global analytics: {e}")
+            return {
+                "period_days": days,
+                "global_model_usage": [],
+                "global_agent_usage": [],
+                "total_requests": 0,
+                "error": str(e),
+                "generated_at": datetime.now(timezone.utc).isoformat()
+            }
+    
+    async def cleanup_old_data(self, days_to_keep: int = 90):
+        """Clean up old analytics data to prevent database bloat."""
+        try:
+            cutoff_time = time.time() - (days_to_keep * 24 * 60 * 60)
+            result = await self.usage_collection.delete_many({"timestamp": {"$lt": cutoff_time}})
+            logger.info(f"[ANALYTICS] Cleaned up {result.deleted_count} old records")
+            return result.deleted_count
+        except Exception as e:
+            logger.error(f"[ANALYTICS] Failed to cleanup old data: {e}")
+            return 0
+
+
+# Global analytics tracker instance
+analytics_tracker: Optional[AnalyticsTracker] = None
+
+def init_analytics(mongo_client, db_name: str = "studybuddy"):
+    """Initialize the global analytics tracker."""
+    global analytics_tracker
+    analytics_tracker = AnalyticsTracker(mongo_client, db_name)
+    logger.info("[ANALYTICS] Analytics tracker initialized")
+
+def get_analytics_tracker() -> Optional[AnalyticsTracker]:
+    """Get the global analytics tracker instance."""
+    return analytics_tracker