Upload folder using huggingface_hub

.env

@@ -0,0 +1,11 @@
+AZURE_OPENAI_KEY = 74fO9RE4s4f7HTSd9SM19Adw6rnECwUuBnfY593dPI7xSHa057RHJQQJ99BEACfhMk5XJ3w3AAAAACOGFVJQ
+
+OPENAI_API_TYPE = azure
+
+OPENAI_EMBEDDINGS_MODEL_NAME = text-embedding-ada-002
+OPENAI_EMBEDDINGS_MODEL_DEPLOYMENT = text-embedding-ada-002
+OPENAI_API_ENDPOINT = https://tal-chatbot-resource2.cognitiveservices.azure.com/
+
+
+AZURE_COSMOS_DB_ENDPOINT = https://tal-chatbot.documents.azure.com:443/
+AZURE_COSMOS_DB_KEY = 6XG3CwRPJeHWAufiMNbWNS2PhBfoSMtPEP5qNGPQJFulXqgJfR9K3xO1sgegOq9vkjwSgmIDqA7hACDbWIzPVA==

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

CosmosDBHandlers/cosmosChatHistoryHandler.py

@@ -0,0 +1,296 @@
+
+# cosmosConnector.py
+from azure.cosmos import exceptions
+from datetime import datetime, timedelta, timezone
+import uuid
+from langchain_openai import AzureOpenAIEmbeddings
+import os
+from azure.cosmos import CosmosClient, PartitionKey
+from typing import List, Optional, Dict
+import logging
+import os
+from dotenv import load_dotenv
+load_dotenv()
+# Initialize Cosmos DB containers
+
+class ChatMemoryHandlerForAnalytics():
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.cosmos_client = CosmosClient(
+            os.getenv("AZURE_COSMOS_DB_ENDPOINT"),
+            os.getenv("AZURE_COSMOS_DB_KEY")
+        )
+        self.logger = logger
+        self.indexing_policy = {
+            "indexingMode": "consistent",
+            "includedPaths": [{"path": "/*"}],  # Indexes all properties, including nested
+            "excludedPaths": [
+                {
+                    "path": '/"_etag"/?'
+                },
+                {
+                    "path": "/embedding/*"
+                }
+                ],
+        }
+
+
+        self.vector_embedding_policy = {
+            "vectorEmbeddings": [
+                {
+                    "path": "/embedding",
+                    "dataType": "float32",
+                    "distanceFunction": "cosine",
+                    "dimensions": 1536,
+                }
+            ]
+        }
+
+        self.embedding_model = AzureOpenAIEmbeddings(
+            azure_endpoint=os.environ["OPENAI_API_ENDPOINT"],
+            azure_deployment=os.environ["OPENAI_EMBEDDINGS_MODEL_DEPLOYMENT"],
+            api_key=os.environ["AZURE_OPENAI_KEY"]
+        )
+
+        self.database = self.cosmos_client.create_database_if_not_exists("TAL_ChatData")
+
+        # Container for chat history
+        self.chat_container = self.database.create_container_if_not_exists(
+            id="ChatHistory",
+            partition_key=PartitionKey(path="/functionUsed"),
+            indexing_policy=self.indexing_policy,
+            vector_embedding_policy=self.vector_embedding_policy
+        )
+
+        # Container for SQL queries
+        self.sql_container = self.database.create_container_if_not_exists(
+            id="GeneratedQueries", 
+            partition_key=PartitionKey(path="/state")
+        )
+        
+    async def _generate_embedding(self, query: str) -> List[float]:
+        """Generate embedding for the given query using Azure OpenAI"""
+        try:
+            return self.embedding_model.embed_query(query)
+        except Exception as e:
+            self.logger.error(f"Embedding generation failed: {str(e)}")
+            raise
+
+    async def get_semantic_faqs(self, limit: int = 5, threshold: float = 0.1) -> List[Dict]:
+        """Retrieve FAQs using vector embeddings for semantic similarity"""
+        try:            
+            query = """
+            SELECT c.question FROM c
+            """
+            raw_results = list(self.chat_container.query_items(
+                query=query,
+                enable_cross_partition_query=True,
+                max_item_count=-1
+            ))
+
+            # Group by question in Python
+            from collections import Counter
+            question_counts = Counter(item['question'] for item in raw_results)
+            top_questions = question_counts.most_common(limit)
+
+            # Generate embeddings for top questions
+            faq_embeddings = {}
+            for question_text, count in top_questions:
+                embedding = await self._generate_embedding(question_text)
+                faq_embeddings[question_text] = {
+                    'embedding': embedding,
+                    'count': count
+                }
+
+            # Cluster similar questions
+            clustered_faqs = []
+            processed = set()
+            
+            for text, data in faq_embeddings.items():
+                if text in processed:
+                    continue
+
+                query = """
+                SELECT TOP 50 c.question, VectorDistance(c.embedding, @embedding) as distance
+                FROM c
+                ORDER BY VectorDistance(c.embedding, @embedding)
+                """
+                parameters = [{"name": "@embedding", "value": data['embedding']}]
+                    
+                similar_results = list(self.chat_container.query_items(
+                    query=query,
+                    parameters=parameters,
+                    enable_cross_partition_query=True
+                ))
+                
+                similarity_threshold = threshold  
+                filtered_results = []
+                for item in similar_results:
+                    similarity = 1 - item['distance']  # Convert distance to similarity
+                    if similarity <= similarity_threshold:
+                        filtered_results.append(item['question'])
+
+                # Count occurrences of similar questions
+                similar_question_counts = Counter(filtered_results)
+                cluster_count = sum(similar_question_counts.values())
+                
+                clustered_faqs.append({
+                    "representative_question": text,
+                    "similar_questions": list(similar_question_counts.keys()),
+                    "total_occurrences": cluster_count,
+                    "similarity_scores": {q: 1 - item['distance'] for item in similar_results for q in [item['question']] if 1 - item['distance'] >= similarity_threshold}
+                })
+                
+                # Mark all similar questions as processed
+                processed.update(filtered_results)
+                clustered_faqs.append({
+                    "representative_question": text,
+                    "similar_questions": [text],
+                    "total_occurrences": data['count'],
+                    "similarity_scores": {text: 1.0}
+                })
+                processed.add(text)
+
+            return sorted(clustered_faqs[:limit], key=lambda x: x['total_occurrences'], reverse=True)
+            
+        except exceptions.CosmosHttpResponseError as ex:
+            print(f"Cosmos DB error: {ex}")
+            self.logger.error(f"Semantic FAQ retrieval failed: {str(e)}")
+            return []
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Semantic FAQ retrieval failed: {str(e)}")
+            return []
+
+    async def get_sql_query_statistics(self):
+        """Get comprehensive SQL query statistics - CORRECTED"""
+        try:
+            # Get total queries
+            total_query = "SELECT VALUE COUNT(1) FROM c"
+            total_queries = list(self.sql_container.query_items(
+                query=total_query,
+                enable_cross_partition_query=True
+            ))[0]
+            
+            # Get queries by state
+            state_query = "SELECT c.state FROM c"
+            state_results = list(self.sql_container.query_items(
+                query=state_query,
+                enable_cross_partition_query=True
+            ))
+            
+            from collections import Counter
+            state_counts = Counter(item['state'] for item in state_results)
+            
+            # Get top original questions
+            question_query = "SELECT c.originalQuestion FROM c"
+            question_results = list(self.sql_container.query_items(
+                query=question_query,
+                enable_cross_partition_query=True
+            ))
+            
+            question_counts = Counter(item['originalQuestion'] for item in question_results)
+            top_questions = [
+                {'question': q, 'count': c} 
+                for q, c in question_counts.most_common(10)
+            ]
+            
+            return {
+                'total_queries': total_queries,
+                'success_count': state_counts.get('success', 0),
+                'error_count': state_counts.get('error', 0),
+                'null_count': state_counts.get('null', 0),  # Changed from 'failed_count'
+                'top_questions': top_questions,
+                'success_rate': (state_counts.get('success', 0) / total_queries * 100) if total_queries > 0 else 0
+            }
+        except Exception as e:
+            print(f"Error getting SQL statistics: {e}")
+            return {'total_queries': 0, 'success_count': 0, 'error_count': 0, 'null_count': 0, 'top_questions': [], 'success_rate': 0}
+
+
+    async def get_sql_query_timeline(self, days=7):
+        """Get SQL query generation timeline"""
+        try:
+            start_date = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat()
+            
+            query = f"""
+            SELECT c.timestamp, c.state, c.originalQuestion
+            FROM c 
+            WHERE c.timestamp >= '{start_date}'
+            ORDER BY c.timestamp
+            """
+            
+            results = list(self.sql_container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            timeline_data = []
+            for item in results:
+                date = datetime.fromisoformat(item['timestamp'].replace('Z', '+00:00'))
+                timeline_data.append({
+                    'date': date.strftime('%Y-%m-%d'),
+                    'hour': date.hour,
+                    'minute': date.minute,
+                    'datetime': date,
+                    'state': item['state'],
+                    'question': item['originalQuestion']
+                })
+            
+            return timeline_data
+        except Exception as e:
+            self.logger.error(f"Error getting SQL timeline: {e}")
+            return []
+
+    async def get_recent_sql_queries(self, limit=20):
+        """Get recent SQL query generations with details"""
+        try:
+            query = f"""
+            SELECT TOP {limit} c.originalQuestion, c.generatedSql, c.state, c.timestamp
+            FROM c
+            ORDER BY c.timestamp DESC
+            """
+            
+            results = list(self.sql_container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            return results
+        except Exception as e:
+            self.logger.error(f"Error getting recent SQL queries: {e}")
+            return []
+
+    async def get_sql_error_analysis(self):
+        """Analyze failed SQL query patterns - CORRECTED"""
+        try:
+            query = """
+            SELECT c.originalQuestion, c.generatedSql, c.state, c.timestamp
+            FROM c
+            WHERE c.state != 'success'
+            ORDER BY c.timestamp DESC
+            """
+            
+            results = list(self.sql_container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            return results
+        except Exception as e:
+            print(f"Error getting SQL error analysis: {e}")
+            return []
+
+import asyncio
+
+
+
+handler = ChatMemoryHandlerForAnalytics()
+
+async def main():
+    faqs = await handler.get_semantic_faqs()
+    for faq in faqs:
+        
+        print("\n",faq["representative_question"],faq["similar_questions"],"\n")
+
+if __name__ == "__main__":
+    asyncio.run(main())

README.md

@@ -1,12 +1,6 @@
 ---
 title: TALAnalyticsDashboard
-emoji: 🐠
-colorFrom: pink
-colorTo: green
+app_file: analytics-dashboard.py
 sdk: gradio
-sdk_version: 5.34.0
-app_file: app.py
-pinned: false
+sdk_version: 5.31.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

analytics-dashboard.py

@@ -0,0 +1,425 @@
+import gradio as gr
+import pandas as pd
+import asyncio
+from datetime import datetime, timedelta, timezone
+import plotly.express as px
+import plotly.graph_objects as go
+from CosmosDBHandlers.cosmosChatHistoryHandler import ChatMemoryHandlerForAnalytics
+
+class ChatAnalyticsDashboard:
+    def __init__(self):
+        self.handler = ChatMemoryHandlerForAnalytics()
+        
+    async def get_chat_statistics(self):
+        """Get basic chat statistics - Fixed version"""
+        try:
+            # Get total chats - this works
+            total_query = "SELECT VALUE COUNT(1) FROM c"
+            total_chats = list(self.handler.chat_container.query_items(
+                query=total_query,
+                enable_cross_partition_query=True
+            ))[0]
+            
+            # Get unique sessions - fetch all and count in Python
+            session_query = "SELECT c.sessionId FROM c"
+            session_results = list(self.handler.chat_container.query_items(
+                query=session_query,
+                enable_cross_partition_query=True
+            ))
+            unique_sessions = len(set(item['sessionId'] for item in session_results))
+            
+            # Get function usage - fetch all and group in Python
+            function_query = "SELECT c.functionUsed FROM c"
+            function_results = list(self.handler.chat_container.query_items(
+                query=function_query,
+                enable_cross_partition_query=True
+            ))
+            
+            # Count function usage in Python
+            from collections import Counter
+            function_counts = Counter(item['functionUsed'] for item in function_results)
+            function_usage = [
+                {'functionUsed': func, 'count': count} 
+                for func, count in function_counts.items()
+            ]
+            
+            return {
+                'total_chats': total_chats,
+                'unique_sessions': unique_sessions,
+                'function_usage': function_usage
+            }
+        except Exception as e:
+            print(f"Error getting statistics: {e}")
+            return {'total_chats': 0, 'unique_sessions': 0, 'function_usage': []}
+    
+    async def get_recent_chats(self, limit=10):
+        """Get recent chat interactions"""
+        try:
+            query = f"""
+            SELECT TOP {limit} c.sessionId, c.question, c.functionUsed, c.answer, c.timestamp
+            FROM c
+            ORDER BY c.timestamp DESC
+            """
+            
+            results = list(self.handler.chat_container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            return results
+        except Exception as e:
+            print(f"Error getting recent chats: {e}")
+            return []
+
+    async def get_chat_timeline(self, days=7):
+        """Enhanced timeline data with minute-level precision"""
+        try:
+            start_date = (datetime.now(timezone.utc) - timedelta(days=days)).isoformat()
+            
+            query = f"""
+            SELECT c.timestamp, c.functionUsed 
+            FROM c 
+            WHERE c.timestamp >= '{start_date}'
+            ORDER BY c.timestamp
+            """
+            
+            results = list(self.handler.chat_container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            # Process for timeline with minute precision
+            timeline_data = []
+            for item in results:
+                date = datetime.fromisoformat(item['timestamp'].replace('Z', '+00:00'))
+                timeline_data.append({
+                    'date': date.strftime('%Y-%m-%d'),
+                    'hour': date.hour,
+                    'minute': date.minute,
+                    'datetime': date,
+                    'function': item['functionUsed']
+                })
+            
+            return timeline_data
+        except Exception as e:
+            print(f"Error getting timeline: {e}")
+            return []
+        
+# Initialize dashboard
+dashboard = ChatAnalyticsDashboard()
+
+def sync_wrapper(async_func):
+    """Wrapper to run async functions in Gradio"""
+    def wrapper(*args, **kwargs):
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        
+        return loop.run_until_complete(async_func(*args, **kwargs))
+    return wrapper
+
+@sync_wrapper
+async def update_sql_statistics():
+    """Update SQL query statistics """
+    stats = await dashboard.handler.get_sql_query_statistics()
+    
+    # Create success rate chart with correct state values
+    if stats['total_queries'] > 0:
+        state_data = pd.DataFrame([
+            {'State': 'Success', 'Count': stats['success_count']},
+            {'State': 'Error', 'Count': stats['error_count']},
+            {'State': 'Null', 'Count': stats['null_count']}  # Changed from 'Failed'
+        ])
+
+        state_chart = px.pie(state_data, values='Count', names='State', 
+                           title='SQL Query Success Rate',
+                           color_discrete_map={'Success': '#10b981', 'Error': '#ef4444', 'Null': '#6b7280'})
+    else:
+        state_chart = px.pie(values=[1], names=['No Data'], title='SQL Query Success Rate')
+    
+    # Create top questions chart
+    if stats['top_questions']:
+        questions_df = pd.DataFrame(stats['top_questions'])
+        questions_chart = px.bar(questions_df.head(5), x='count', y='question', 
+                                orientation='h', title='Top 5 Most Generated Queries')
+        questions_chart.update_layout(yaxis={'categoryorder': 'total ascending'})
+    else:
+        questions_chart = px.bar(x=[0], y=['No Data'], title='Top Generated Queries')
+    
+    return (
+        f"**Total SQL Queries:** {stats['total_queries']}",
+        f"**Success Rate:** {stats['success_rate']:.1f}%",
+        f"**Error/Null Queries:** {stats['error_count'] + stats['null_count']}",  # Updated label
+        state_chart,
+        questions_chart
+    )
+
+
+
+@sync_wrapper
+async def get_recent_sql_queries():
+    """Get recent SQL query generations"""
+    recent = await dashboard.handler.get_recent_sql_queries(limit=15)
+    
+    if recent:
+        recent_data = []
+        for query in recent:
+            recent_data.append({
+                'Original Question': query['originalQuestion'][:60] + '...' if len(query['originalQuestion']) > 60 else query['originalQuestion'],
+                'Generated SQL': query['generatedSql'][:80] + '...' if len(query['generatedSql']) > 80 else query['generatedSql'],
+                'State': query['state'],
+                'Timestamp': datetime.fromisoformat(query['timestamp'].replace('Z', '+00:00')).strftime('%Y-%m-%d %H:%M')
+            })
+        
+        return pd.DataFrame(recent_data)
+    else:
+        return pd.DataFrame({'Message': ['No recent SQL queries']})
+
+@sync_wrapper
+async def get_sql_error_analysis():
+    """Get failed SQL query analysis"""
+    errors = await dashboard.handler.get_sql_error_analysis()
+    
+    if errors:
+        error_data = []
+        for error in errors[:10]:  # Limit to 10 most recent errors
+            error_data.append({
+                'Original Question': error['originalQuestion'][:50] + '...' if len(error['originalQuestion']) > 50 else error['originalQuestion'],
+                'Generated SQL': error['generatedSql'][:60] + '...' if len(error['generatedSql']) > 60 else error['generatedSql'],
+                'State': error['state'],
+                'Timestamp': datetime.fromisoformat(error['timestamp'].replace('Z', '+00:00')).strftime('%Y-%m-%d %H:%M')
+            })
+        
+        return pd.DataFrame(error_data)
+    else:
+        return pd.DataFrame({'Message': ['No failed queries found']})
+
+@sync_wrapper
+async def update_statistics():
+    """Update dashboard statistics"""
+    stats = await dashboard.get_chat_statistics()
+    
+    # Create function usage chart
+    if stats['function_usage']:
+        func_df = pd.DataFrame(stats['function_usage'])
+        func_chart = px.pie(func_df, values='count', names='functionUsed', 
+                           title='Function Usage Distribution')
+    else:
+        func_chart = px.pie(values=[1], names=['No Data'], title='Function Usage Distribution')
+    
+    return (
+        f"**Total Chats:** {stats['total_chats']}",
+        f"**Unique Sessions:** {stats['unique_sessions']}",
+        func_chart
+    )
+
+
+@sync_wrapper
+async def update_timeline(days):
+    """Enhanced timeline function with adaptive granularity"""
+    timeline_data = await dashboard.get_chat_timeline(days)
+    
+    if not timeline_data:
+        # Return empty chart if no data
+        empty_fig = go.Figure()
+        empty_fig.add_annotation(
+            text="No data available for selected period",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False
+        )
+        empty_fig.update_layout(title="Chat Activity Timeline")
+        return empty_fig
+    
+    df = pd.DataFrame(timeline_data)
+    
+    if days > 1:
+        # Multi-day view: Group by date for daily line plot
+        daily_counts = df.groupby('date').size().reset_index(name='count')
+        daily_counts['date'] = pd.to_datetime(daily_counts['date'])
+        
+        timeline_chart = px.line(
+            daily_counts, 
+            x='date', 
+            y='count',
+            title=f'Daily Chat Activity - Last {days} Days',
+            markers=True,
+            line_shape='linear'
+        )
+        
+        timeline_chart.update_layout(
+            xaxis_title="Date",
+            yaxis_title="Number of Chats",
+            hovermode='x unified'
+        )
+        
+    # In the single day section of update_timeline:
+    else:
+        # Single day view: Group by 15-minute intervals
+        df['datetime'] = pd.to_datetime(df['date'] + ' ' + 
+                                    df['hour'].astype(str) + ':' + 
+                                    df['minute'].astype(str) + ':00')
+        
+        # Create 15-minute intervals
+        df['interval'] = df['datetime'].dt.floor('15min')
+        interval_counts = df.groupby('interval').size().reset_index(name='count')
+        
+        timeline_chart = px.line(
+            interval_counts,
+            x='interval',
+            y='count',
+            title=f'Chat Activity by 15-min Intervals - {interval_counts.iloc[0]["interval"].strftime("%Y-%m-%d")}',
+            markers=True,
+            line_shape='linear'
+        )
+        
+        timeline_chart.update_layout(
+            xaxis_title="Time",
+            yaxis_title="Number of Chats",
+            xaxis=dict(
+                tickformat='%H:%M',
+                dtick=900000  # 15-minute intervals
+            ),
+            hovermode='x unified'
+        )
+
+    return timeline_chart
+
+
+@sync_wrapper
+async def get_faqs():
+    """Get semantic FAQs"""
+    faqs = await dashboard.handler.get_semantic_faqs(limit=10)
+    
+    if faqs:
+        faq_data = []
+        for faq in faqs:
+            faq_data.append({
+                'Question': faq['representative_question'][:100] + '...' if len(faq['representative_question']) > 100 else faq['representative_question'],
+                'Similar Questions Count': len(faq['similar_questions']),
+                'Total Occurrences': faq['total_occurrences']
+            })
+        
+        return pd.DataFrame(faq_data)
+    else:
+        return pd.DataFrame({'Message': ['No FAQ data available']})
+
+@sync_wrapper
+async def get_recent_interactions():
+    """Get recent chat interactions"""
+    recent = await dashboard.get_recent_chats(limit=20)
+    
+    if recent:
+        recent_data = []
+        for chat in recent:
+            recent_data.append({
+                'Session ID': chat['sessionId'][:8] + '...',
+                'Question': chat['question'][:50] + '...' if len(chat['question']) > 50 else chat['question'],
+                'Function': chat['functionUsed'],
+                'Timestamp': datetime.fromisoformat(chat['timestamp'].replace('Z', '+00:00')).strftime('%Y-%m-%d %H:%M')
+            })
+        
+        return pd.DataFrame(recent_data)
+    else:
+        return pd.DataFrame({'Message': ['No recent interactions']})
+
+theme = gr.themes.Citrus(
+    secondary_hue="amber",
+    font=[gr.themes.GoogleFont('Inter'), 'ui-sans-serif', 'system-ui', 'sans-serif'],
+    font_mono=[gr.themes.GoogleFont('Roboto Mono'), 'ui-monospace', 'Consolas', 'monospace'],
+)
+
+with gr.Blocks(theme=theme, 
+                title="TAL Chat Analytics Dashboard") as demo:
+
+    gr.Markdown("# Chat Analytics Dashboard")
+    gr.Markdown("### Real-time analytics for TAL Chatbot")
+    
+    with gr.Row():
+        total_chats = gr.Markdown("**Total Chats:** Loading...")
+        unique_sessions = gr.Markdown("**Unique Sessions:** Loading...")
+
+    with gr.Tabs():
+        with gr.TabItem("Function Usage Distribution"):
+            function_chart = gr.Plot(label="Function Usage Distribution")
+
+        with gr.TabItem("📈 Timeline Analysis"):
+            days_slider = gr.Slider(minimum=1, maximum=30, value=7, step=1, 
+                                  label="Days to analyze")
+            with gr.Row():
+                timeline_plot = gr.Plot(label="Daily Chat Activity")
+        
+        with gr.TabItem("❓ Frequently Asked Questions"):
+            faq_table = gr.DataFrame(label="Semantic FAQs", interactive=False)
+        
+        with gr.TabItem("💬 Recent Interactions"):
+            recent_table = gr.DataFrame(label="Recent Chat Interactions", interactive=False)
+
+        with gr.TabItem("🔍 SQL Query Analytics", elem_id="sql-tab"):
+            # SQL Statistics Section
+            gr.Markdown("### 📊 SQL Generation Statistics")
+            with gr.Row():
+                with gr.Column(elem_classes="stats-card"):
+                    total_sql_queries = gr.Markdown("**Total SQL Queries:** Loading...")
+                with gr.Column(elem_classes="stats-card"):
+                    sql_success_rate = gr.Markdown("**Success Rate:** Loading...")
+                with gr.Column(elem_classes="stats-card"):
+                    failed_sql_queries = gr.Markdown("**Failed Queries:** Loading...")
+            
+            # SQL Charts Section
+            with gr.Row():
+                with gr.Column(elem_classes="plot-container"):
+                    sql_state_chart = gr.Plot(label="SQL Query Success Distribution")
+                with gr.Column(elem_classes="plot-container"):
+                    top_questions_chart = gr.Plot(label="Most Generated Queries")
+            
+            # Recent SQL Queries Section
+            gr.Markdown("### 📝 Recent SQL Generations")
+            with gr.Column(elem_classes="plot-container"):
+                recent_sql_table = gr.DataFrame(
+                    label="Latest SQL Query Generations", 
+                    interactive=False,
+                    elem_classes="dataframe"
+                )
+            
+            # Error Analysis Section
+            gr.Markdown("### ⚠️ Failed Query Analysis")
+            with gr.Column(elem_classes="plot-container"):
+                sql_errors_table = gr.DataFrame(
+                    label="Recent Failed SQL Queries", 
+                    interactive=False,
+                    elem_classes="dataframe"
+                )
+    refresh_btn = gr.Button("🔄 Refresh Dashboard", variant="primary")
+    
+    
+# Update event handlers
+    demo.load(update_sql_statistics, outputs=[total_sql_queries, sql_success_rate, failed_sql_queries, sql_state_chart, top_questions_chart])
+    demo.load(get_recent_sql_queries, outputs=[recent_sql_table])
+    demo.load(get_sql_error_analysis, outputs=[sql_errors_table])
+
+    refresh_btn.click(update_sql_statistics, outputs=[total_sql_queries, sql_success_rate, failed_sql_queries, sql_state_chart, top_questions_chart])
+    refresh_btn.click(get_recent_sql_queries, outputs=[recent_sql_table])
+    refresh_btn.click(get_sql_error_analysis, outputs=[sql_errors_table])
+
+    days_slider.change(update_timeline, inputs=[days_slider], 
+                        outputs=[timeline_plot])
+
+    # Auto-refresh components
+   
+    # # Event handlers
+    demo.load(update_statistics, outputs=[total_chats, unique_sessions, function_chart])
+    demo.load(lambda: update_timeline(7), outputs=[timeline_plot])
+    demo.load(get_faqs, outputs=[faq_table])
+    demo.load(get_recent_interactions, outputs=[recent_table])
+    
+    refresh_btn.click(update_statistics, outputs=[total_chats, unique_sessions, function_chart])
+    refresh_btn.click(lambda: update_timeline(7), outputs=[timeline_plot])
+    refresh_btn.click(get_faqs, outputs=[faq_table])
+    refresh_btn.click(get_recent_interactions, outputs=[recent_table])
+    
+    
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

requirements.txt

@@ -0,0 +1,3 @@
+semantic-kernel
+azure-cosmos
+plotly