Update app.py

app.py

@@ -2,6 +2,12 @@ import gradio as gr
 import os
 import re
 from groq import Groq
+import pandas as pd
+import matplotlib.pyplot as plt
+import io
+import base64
+from datetime import datetime, timedelta
+import json
 
 def validate_api_key(api_key):
     """Validate if the API key has the correct format."""
@@ -32,31 +38,81 @@ def test_api_connection(api_key):
         else:
             return False, f"Error connecting to Groq API: {str(e)}"
 
-def chat_with_groq(api_key, model, user_message, temperature, max_tokens, top_p, chat_history):
-    """
-    Interact with the Groq API to get a response.
-    """
-    # Validate API key
+# Ensure analytics directory exists
+os.makedirs("analytics", exist_ok=True)
+
+def log_chat_interaction(model, tokens_used, response_time, user_message_length):
+    """Log chat interactions for analytics"""
+    timestamp = datetime.now().isoformat()
+    
+    log_file = "analytics/chat_log.json"
+    
+    log_entry = {
+        "timestamp": timestamp,
+        "model": model,
+        "tokens_used": tokens_used,
+        "response_time_sec": response_time,
+        "user_message_length": user_message_length
+    }
+    
+    # Append to existing log or create new file
+    if os.path.exists(log_file):
+        try:
+            with open(log_file, "r") as f:
+                logs = json.load(f)
+        except:
+            logs = []
+    else:
+        logs = []
+    
+    logs.append(log_entry)
+    
+    with open(log_file, "w") as f:
+        json.dump(logs, f, indent=2)
+
+def get_template_prompt(template_name):
+    """Get system prompt for a given template name"""
+    templates = {
+        "": "",  # Empty template
+        "General Assistant": "You are a helpful, harmless, and honest AI assistant.",
+        "Code Helper": "You are a programming assistant. Provide detailed code explanations and examples.",
+        "Creative Writer": "You are a creative writing assistant. Generate engaging and imaginative content.",
+        "Technical Expert": "You are a technical expert. Provide accurate, detailed technical information.",
+        "Data Analyst": "You are a data analysis assistant. Help interpret and analyze data effectively."
+    }
+    
+    return templates.get(template_name, "")
+
+def enhanced_chat_with_groq(api_key, model, user_message, temperature, max_tokens, top_p, chat_history, template_name=""):
+    """Enhanced chat function with analytics logging"""
+    start_time = datetime.now()
+    
+    # Get system prompt if template is provided
+    system_prompt = get_template_prompt(template_name) if template_name else ""
+    
+    # Validate and process as before
     is_valid, message = validate_api_key(api_key)
     if not is_valid:
         return chat_history + [[user_message, f"Error: {message}"]]
     
-    # Test API connection
     connection_valid, connection_message = test_api_connection(api_key)
     if not connection_valid:
         return chat_history + [[user_message, f"Error: {connection_message}"]]
     
     try:
-        # Format history for the API
+        # Format history
         messages = []
+        
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
         for human, assistant in chat_history:
             messages.append({"role": "user", "content": human})
             messages.append({"role": "assistant", "content": assistant})
         
-        # Add the current message
         messages.append({"role": "user", "content": user_message})
         
-        # Create the client and make the API call
+        # Make API call
         client = Groq(api_key=api_key)
         response = client.chat.completions.create(
             model=model,
@@ -66,10 +122,22 @@ def chat_with_groq(api_key, model, user_message, temperature, max_tokens, top_p,
             top_p=top_p
         )
         
-        # Extract the response text
+        # Calculate metrics
+        end_time = datetime.now()
+        response_time = (end_time - start_time).total_seconds()
+        tokens_used = response.usage.total_tokens
+        
+        # Log the interaction
+        log_chat_interaction(
+            model=model,
+            tokens_used=tokens_used,
+            response_time=response_time,
+            user_message_length=len(user_message)
+        )
+        
+        # Extract response
         assistant_response = response.choices[0].message.content
         
-        # Return updated chat history
         return chat_history + [[user_message, assistant_response]]
     
     except Exception as e:
@@ -80,6 +148,101 @@ def clear_conversation():
     """Clear the conversation history."""
     return []
 
+def generate_analytics():
+    """Generate analytics from the chat log"""
+    log_file = "analytics/chat_log.json"
+    
+    if not os.path.exists(log_file):
+        return "No analytics data available yet.", None, None, None, None
+    
+    try:
+        with open(log_file, "r") as f:
+            logs = json.load(f)
+        
+        if not logs:
+            return "No analytics data available yet.", None, None, None, None
+        
+        # Convert to DataFrame
+        df = pd.DataFrame(logs)
+        df["timestamp"] = pd.to_datetime(df["timestamp"])
+        
+        # Generate usage by model chart
+        model_usage = df.groupby("model").agg({
+            "tokens_used": "sum",
+            "timestamp": "count"
+        }).reset_index()
+        model_usage.columns = ["model", "total_tokens", "request_count"]
+        
+        plt.figure(figsize=(10, 6))
+        plt.bar(model_usage["model"], model_usage["total_tokens"])
+        plt.title("Token Usage by Model")
+        plt.xlabel("Model")
+        plt.ylabel("Total Tokens Used")
+        plt.xticks(rotation=45)
+        
+        model_usage_img = io.BytesIO()
+        plt.savefig(model_usage_img, format="png", bbox_inches="tight")
+        model_usage_img.seek(0)
+        model_usage_b64 = base64.b64encode(model_usage_img.read()).decode("utf-8")
+        plt.close()
+        
+        # Generate usage over time chart
+        df["date"] = df["timestamp"].dt.date
+        daily_usage = df.groupby("date").agg({
+            "tokens_used": "sum"
+        }).reset_index()
+        
+        plt.figure(figsize=(10, 6))
+        plt.plot(daily_usage["date"], daily_usage["tokens_used"], marker="o")
+        plt.title("Daily Token Usage")
+        plt.xlabel("Date")
+        plt.ylabel("Tokens Used")
+        plt.grid(True)
+        
+        daily_usage_img = io.BytesIO()
+        plt.savefig(daily_usage_img, format="png", bbox_inches="tight")
+        daily_usage_img.seek(0)
+        daily_usage_b64 = base64.b64encode(daily_usage_img.read()).decode("utf-8")
+        plt.close()
+        
+        # Generate response time chart
+        model_response_time = df.groupby("model").agg({
+            "response_time_sec": "mean"
+        }).reset_index()
+        
+        plt.figure(figsize=(10, 6))
+        plt.bar(model_response_time["model"], model_response_time["response_time_sec"])
+        plt.title("Average Response Time by Model")
+        plt.xlabel("Model")
+        plt.ylabel("Response Time (seconds)")
+        plt.xticks(rotation=45)
+        
+        response_time_img = io.BytesIO()
+        plt.savefig(response_time_img, format="png", bbox_inches="tight")
+        response_time_img.seek(0)
+        response_time_b64 = base64.b64encode(response_time_img.read()).decode("utf-8")
+        plt.close()
+        
+        # Summary statistics
+        total_tokens = df["tokens_used"].sum()
+        total_requests = len(df)
+        avg_response_time = df["response_time_sec"].mean()
+        
+        summary = f"""
+        ## Analytics Summary
+        
+        - **Total API Requests**: {total_requests}
+        - **Total Tokens Used**: {total_tokens:,}
+        - **Average Response Time**: {avg_response_time:.2f} seconds
+        - **Most Used Model**: {model_usage.iloc[model_usage["request_count"].argmax()]["model"]}
+        - **Date Range**: {df["timestamp"].min().date()} to {df["timestamp"].max().date()}
+        """
+        
+        return summary, model_usage_b64, daily_usage_b64, response_time_b64, df.to_dict("records")
+    
+    except Exception as e:
+        return f"Error generating analytics: {str(e)}", None, None, None, None
+
 # Define available models
 models = [
     "llama3-70b-8192",
@@ -89,102 +252,133 @@ models = [
     "allam-2-7b"
 ]
 
+# Define templates
+templates = ["", "General Assistant", "Code Helper", "Creative Writer", "Technical Expert", "Data Analyst"]
+
 # Create the Gradio interface
 with gr.Blocks(title="Groq AI Chat Playground") as app:
     gr.Markdown("# Groq AI Chat Playground")
-
-    # New model information accordion
-    with gr.Accordion("ℹ️ Model Information - Learn about available models", open=False):
-        gr.Markdown("""
-        ### Available Models and Use Cases
-        
-        **llama3-70b-8192**
-        - Meta's most powerful language model
-        - 70 billion parameters with 8192 token context window
-        - Best for: Complex reasoning, sophisticated content generation, creative writing, and detailed analysis
-        - Optimal for users needing the highest quality AI responses
-        
-        **llama3-8b-8192**
-        - Lighter version of Llama 3
-        - 8 billion parameters with 8192 token context window
-        - Best for: Faster responses, everyday tasks, simpler queries
-        - Good balance between performance and speed
-        
-        **mistral-saba-24b**
-        - Mistral AI's advanced model
-        - 24 billion parameters
-        - Best for: High-quality reasoning, code generation, and structured outputs
-        - Excellent for technical and professional use cases
-        
-        **gemma2-9b-it**
-        - Google's instruction-tuned model
-        - 9 billion parameters
-        - Best for: Following specific instructions, educational content, and general knowledge queries
-        - Well-rounded performance for various tasks
-        
-        **allam-2-7b**
-        - Specialized model from Aleph Alpha
-        - 7 billion parameters
-        - Best for: Multilingual support, concise responses, and straightforward Q&A
-        - Good for international users and simpler applications
-        
-        *Note: Larger models generally provide higher quality responses but may take slightly longer to generate.*
-        """)
-    
-    gr.Markdown("Enter your Groq API key to start chatting with AI models.")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            api_key_input = gr.Textbox(
-                label="Groq API Key", 
-                placeholder="Enter your Groq API key (starts with gsk_)",
-                type="password"
-            )
+    
+    # Create tabs for Chat and Analytics
+    with gr.Tabs():
+        with gr.Tab("Chat"):
+            # New model information accordion
+            with gr.Accordion("ℹ️ Model Information - Learn about available models", open=False):
+                gr.Markdown("""
+                ### Available Models and Use Cases
+                
+                **llama3-70b-8192**
+                - Meta's most powerful language model
+                - 70 billion parameters with 8192 token context window
+                - Best for: Complex reasoning, sophisticated content generation, creative writing, and detailed analysis
+                - Optimal for users needing the highest quality AI responses
+                
+                **llama3-8b-8192**
+                - Lighter version of Llama 3
+                - 8 billion parameters with 8192 token context window
+                - Best for: Faster responses, everyday tasks, simpler queries
+                - Good balance between performance and speed
+                
+                **mistral-saba-24b**
+                - Mistral AI's advanced model
+                - 24 billion parameters
+                - Best for: High-quality reasoning, code generation, and structured outputs
+                - Excellent for technical and professional use cases
+                
+                **gemma2-9b-it**
+                - Google's instruction-tuned model
+                - 9 billion parameters
+                - Best for: Following specific instructions, educational content, and general knowledge queries
+                - Well-rounded performance for various tasks
+                
+                **allam-2-7b**
+                - Specialized model from Aleph Alpha
+                - 7 billion parameters
+                - Best for: Multilingual support, concise responses, and straightforward Q&A
+                - Good for international users and simpler applications
+                
+                *Note: Larger models generally provide higher quality responses but may take slightly longer to generate.*
+                """)
             
-        with gr.Column(scale=1):
-            test_button = gr.Button("Test API Connection")
-            api_status = gr.Textbox(label="API Status", interactive=False)
-    
-    with gr.Row():
-        with gr.Column():
-            model_dropdown = gr.Dropdown(
-                choices=models,
-                label="Select Model",
-                value="llama3-70b-8192"
-            )
-    
-    with gr.Row():
-        with gr.Column():
-            with gr.Accordion("Advanced Settings", open=False):
-                temperature_slider = gr.Slider(
-                    minimum=0.0, maximum=1.0, value=0.7, step=0.01,
-                    label="Temperature (higher = more creative, lower = more focused)"
-                )
-                max_tokens_slider = gr.Slider(
-                    minimum=256, maximum=8192, value=4096, step=256,
-                    label="Max Tokens (maximum length of response)"
-                )
-                top_p_slider = gr.Slider(
-                    minimum=0.0, maximum=1.0, value=0.95, step=0.01,
-                    label="Top P (nucleus sampling probability threshold)"
+            gr.Markdown("Enter your Groq API key to start chatting with AI models.")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    api_key_input = gr.Textbox(
+                        label="Groq API Key", 
+                        placeholder="Enter your Groq API key (starts with gsk_)",
+                        type="password"
+                    )
+                    
+                with gr.Column(scale=1):
+                    test_button = gr.Button("Test API Connection")
+                    api_status = gr.Textbox(label="API Status", interactive=False)
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    model_dropdown = gr.Dropdown(
+                        choices=models,
+                        label="Select Model",
+                        value="llama3-70b-8192"
+                    )
+                with gr.Column(scale=1):
+                    template_dropdown = gr.Dropdown(
+                        choices=templates,
+                        label="Select Template",
+                        value=""
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    with gr.Accordion("Advanced Settings", open=False):
+                        temperature_slider = gr.Slider(
+                            minimum=0.0, maximum=1.0, value=0.7, step=0.01,
+                            label="Temperature (higher = more creative, lower = more focused)"
+                        )
+                        max_tokens_slider = gr.Slider(
+                            minimum=256, maximum=8192, value=4096, step=256,
+                            label="Max Tokens (maximum length of response)"
+                        )
+                        top_p_slider = gr.Slider(
+                            minimum=0.0, maximum=1.0, value=0.95, step=0.01,
+                            label="Top P (nucleus sampling probability threshold)"
+                        )
+            
+            chatbot = gr.Chatbot(label="Conversation", height=500)
+            
+            with gr.Row():
+                message_input = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Type your message here...",
+                    lines=3
                 )
-    
-    chatbot = gr.Chatbot(label="Conversation", height=500)
-    
-    with gr.Row():
-        message_input = gr.Textbox(
-            label="Your Message",
-            placeholder="Type your message here...",
-            lines=3
-        )
-    
-    with gr.Row():
-        submit_button = gr.Button("Send", variant="primary")
-        clear_button = gr.Button("Clear Conversation")
+            
+            with gr.Row():
+                submit_button = gr.Button("Send", variant="primary")
+                clear_button = gr.Button("Clear Conversation")
+            
+        # Analytics Dashboard Tab
+        with gr.Tab("Analytics Dashboard"):
+            with gr.Column():
+                gr.Markdown("# Usage Analytics Dashboard")
+                refresh_analytics_button = gr.Button("Refresh Analytics")
+                
+                analytics_summary = gr.Markdown()
+                
+                with gr.Row():
+                    with gr.Column():
+                        model_usage_chart = gr.Image(label="Token Usage by Model")
+                    with gr.Column():
+                        daily_usage_chart = gr.Image(label="Daily Token Usage")
+                
+                response_time_chart = gr.Image(label="Response Time by Model")
+                
+                with gr.Accordion("Raw Data", open=False):
+                    analytics_table = gr.DataFrame(label="Raw Analytics Data")
     
     # Connect components with functions
     submit_button.click(
-        fn=chat_with_groq,
+        fn=enhanced_chat_with_groq,
         inputs=[
             api_key_input,
             model_dropdown,
@@ -192,7 +386,8 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
             temperature_slider,
             max_tokens_slider,
             top_p_slider,
-            chatbot
+            chatbot,
+            template_dropdown
         ],
         outputs=chatbot
     ).then(
@@ -202,7 +397,7 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
     )
     
     message_input.submit(
-        fn=chat_with_groq,
+        fn=enhanced_chat_with_groq,
         inputs=[
             api_key_input,
             model_dropdown,
@@ -210,7 +405,8 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
             temperature_slider,
             max_tokens_slider,
             top_p_slider,
-            chatbot
+            chatbot,
+            template_dropdown
         ],
         outputs=chatbot
     ).then(
@@ -230,6 +426,12 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
         inputs=[api_key_input],
         outputs=[api_status]
     )
+    
+    refresh_analytics_button.click(
+        fn=generate_analytics,
+        inputs=[],
+        outputs=[analytics_summary, model_usage_chart, daily_usage_chart, response_time_chart, analytics_table]
+    )
 
 # Launch the app
 if __name__ == "__main__":