Update app.py

app.py

@@ -11,7 +11,6 @@ import json
 
 def validate_api_key(api_key):
     """Validate if the API key has the correct format."""
-    # Basic format check for Groq API keys (they typically start with 'gsk_')
     if not api_key.strip():
         return False, "API key cannot be empty"
     
@@ -24,7 +23,6 @@ def test_api_connection(api_key):
     """Test the API connection with a minimal request."""
     try:
         client = Groq(api_key=api_key)
-        # Making a minimal API call to test the connection
         client.chat.completions.create(
             model="llama3-70b-8192",
             messages=[{"role": "user", "content": "test"}],
@@ -32,13 +30,11 @@ def test_api_connection(api_key):
         )
         return True, "API connection successful"
     except Exception as e:
-        # Handle all exceptions since Groq might not expose specific error types
         if "authentication" in str(e).lower() or "api key" in str(e).lower():
             return False, "Authentication failed: Invalid API key"
         else:
             return False, f"Error connecting to Groq API: {str(e)}"
 
-# Ensure analytics directory exists
 os.makedirs("analytics", exist_ok=True)
 
 def log_chat_interaction(model, tokens_used, response_time, user_message_length):
@@ -55,7 +51,6 @@ def log_chat_interaction(model, tokens_used, response_time, user_message_length)
         "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:
@@ -86,10 +81,8 @@ def enhanced_chat_with_groq(api_key, model, user_message, temperature, max_token
     """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}"]]
@@ -99,7 +92,6 @@ def enhanced_chat_with_groq(api_key, model, user_message, temperature, max_token
         return chat_history + [[user_message, f"Error: {connection_message}"]]
     
     try:
-        # Format history
         messages = []
         
         if system_prompt:
@@ -111,7 +103,6 @@ def enhanced_chat_with_groq(api_key, model, user_message, temperature, max_token
         
         messages.append({"role": "user", "content": user_message})
         
-        # Make API call
         client = Groq(api_key=api_key)
         response = client.chat.completions.create(
             model=model,
@@ -121,12 +112,10 @@ def enhanced_chat_with_groq(api_key, model, user_message, temperature, max_token
             top_p=top_p
         )
         
-        # 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,
@@ -134,7 +123,6 @@ def enhanced_chat_with_groq(api_key, model, user_message, temperature, max_token
             user_message_length=len(user_message)
         )
         
-        # Extract response
         assistant_response = response.choices[0].message.content
         
         return chat_history + [[user_message, assistant_response]]
@@ -147,13 +135,6 @@ def clear_conversation():
     """Clear the conversation history."""
     return []
 
-def clear_analytics():
-    """Clear the analytics data."""
-    log_file = "analytics/chat_log.json"
-    if os.path.exists(log_file):
-        os.remove(log_file)
-    return "Analytics data has been cleared."
-
 def plt_to_html(fig):
     """Convert matplotlib figure to HTML img tag"""
     buf = io.BytesIO()
@@ -168,20 +149,18 @@ def generate_analytics():
     log_file = "analytics/chat_log.json"
     
     if not os.path.exists(log_file):
-        return "No analytics data available yet.", None, None, []
+        return "No analytics data available yet.", 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, []
+            return "No analytics data available yet.", 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"
@@ -197,7 +176,20 @@ def generate_analytics():
         plt.tight_layout()
         model_usage_img = plt_to_html(fig1)
         
-        # Generate response time chart
+        df["date"] = df["timestamp"].dt.date
+        daily_usage = df.groupby("date").agg({
+            "tokens_used": "sum"
+        }).reset_index()
+        
+        fig2 = 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)
+        plt.tight_layout()
+        daily_usage_img = plt_to_html(fig2)
+        
         model_response_time = df.groupby("model").agg({
             "response_time_sec": "mean"
         }).reset_index()
@@ -211,12 +203,10 @@ def generate_analytics():
         plt.tight_layout()
         response_time_img = plt_to_html(fig3)
         
-        # Summary statistics
         total_tokens = df["tokens_used"].sum()
         total_requests = len(df)
         avg_response_time = df["response_time_sec"].mean()
         
-        # Handling the case where there might not be enough data
         if not model_usage.empty:
             most_used_model = model_usage.iloc[model_usage["request_count"].argmax()]["model"]
         else:
@@ -224,7 +214,7 @@ def generate_analytics():
         
         summary = f"""
         ## Analytics Summary
-        
+
         - **Total API Requests**: {total_requests}
         - **Total Tokens Used**: {total_tokens:,}
         - **Average Response Time**: {avg_response_time:.2f} seconds
@@ -232,13 +222,21 @@ def generate_analytics():
         - **Date Range**: {df["timestamp"].min().date()} to {df["timestamp"].max().date()}
         """
         
-        return summary, model_usage_img, response_time_img, df.to_dict("records")
+        return summary, model_usage_img, daily_usage_img, response_time_img, df.to_dict("records")
     
     except Exception as e:
         error_message = f"Error generating analytics: {str(e)}"
-        return error_message, None, None, []
+        return error_message, None, None, None, []
+
+def clear_analytics():
+    """Clear the analytics data"""
+    log_file = "analytics/chat_log.json"
+    
+    if os.path.exists(log_file):
+        os.remove(log_file)
+    
+    return "Analytics data has been cleared.", None, None, None
 
-# Define available models
 models = [
     "llama3-70b-8192",
     "llama3-8b-8192",
@@ -247,19 +245,49 @@ 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")
     
-    # 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...""")
+                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.")
             
@@ -318,7 +346,6 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
                 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")
@@ -330,16 +357,23 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
                 with gr.Row():
                     with gr.Column():
                         model_usage_chart = gr.HTML(label="Token Usage by Model")
+                    with gr.Column():
+                        response_time_chart = gr.HTML(label="Response Time by Model")
                 
-                response_time_chart = gr.HTML(label="Response Time by Model")
-                
-                with gr.Accordion("Raw Data", open=False):
-                    analytics_table = gr.DataFrame(label="Raw Analytics Data")
+                analytics_table = gr.DataFrame(label="Raw Analytics Data")
     
-    # Connect components with functions
     submit_button.click(
         fn=enhanced_chat_with_groq,
-        inputs=[api_key_input, model_dropdown, message_input, temperature_slider, max_tokens_slider, top_p_slider, chatbot, template_dropdown],
+        inputs=[
+            api_key_input,
+            model_dropdown,
+            message_input,
+            temperature_slider,
+            max_tokens_slider,
+            top_p_slider,
+            chatbot,
+            template_dropdown
+        ],
         outputs=chatbot
     ).then(
         fn=lambda: "",
@@ -349,7 +383,16 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
     
     message_input.submit(
         fn=enhanced_chat_with_groq,
-        inputs=[api_key_input, model_dropdown, message_input, temperature_slider, max_tokens_slider, top_p_slider, chatbot, template_dropdown],
+        inputs=[
+            api_key_input,
+            model_dropdown,
+            message_input,
+            temperature_slider,
+            max_tokens_slider,
+            top_p_slider,
+            chatbot,
+            template_dropdown
+        ],
         outputs=chatbot
     ).then(
         fn=lambda: "",
@@ -381,6 +424,5 @@ with gr.Blocks(title="Groq AI Chat Playground") as app:
         outputs=[analytics_summary, model_usage_chart, response_time_chart, analytics_table]
     )
 
-# Launch the app
 if __name__ == "__main__":
     app.launch(share=False)