Update app.py

app.py

@@ -11,6 +11,7 @@ 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"
     
@@ -23,6 +24,7 @@ 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"}],
@@ -30,11 +32,13 @@ 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):
@@ -51,6 +55,7 @@ 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:
@@ -81,8 +86,10 @@ 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}"]]
@@ -92,6 +99,7 @@ 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:
@@ -103,6 +111,7 @@ 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,
@@ -112,10 +121,12 @@ 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,
@@ -123,6 +134,7 @@ 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]]
@@ -135,6 +147,13 @@ 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()
@@ -149,18 +168,20 @@ def generate_analytics():
     log_file = "analytics/chat_log.json"
     
     if not os.path.exists(log_file):
-        return "No analytics data available yet.", None, None, None, []
+        return "No analytics data available yet.", 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, []
+            return "No analytics data available yet.", 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"
@@ -176,20 +197,7 @@ def generate_analytics():
         plt.tight_layout()
         model_usage_img = plt_to_html(fig1)
         
-        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)
-        
+        # Generate response time chart
         model_response_time = df.groupby("model").agg({
             "response_time_sec": "mean"
         }).reset_index()
@@ -203,10 +211,12 @@ 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:
@@ -214,7 +224,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
@@ -222,21 +232,13 @@ def generate_analytics():
         - **Date Range**: {df["timestamp"].min().date()} to {df["timestamp"].max().date()}
         """
         
-        return summary, model_usage_img, daily_usage_img, response_time_img, df.to_dict("records")
+        return summary, model_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, 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
+        return error_message, None, None, []
 
+# Define available models
 models = [
     "llama3-70b-8192",
     "llama3-8b-8192",
@@ -245,49 +247,19 @@ 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
-
-                **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(""" ### Available Models and Use Cases...""")
             
             gr.Markdown("Enter your Groq API key to start chatting with AI models.")
             
@@ -346,6 +318,7 @@ 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")
@@ -357,23 +330,16 @@ 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")
                 
-                analytics_table = gr.DataFrame(label="Raw Analytics Data")
+                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")
     
+    # 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: "",
@@ -383,16 +349,7 @@ 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: "",
@@ -424,5 +381,6 @@ 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)