Update app.py

app.py

@@ -53,39 +53,37 @@ def clean_awr_content(content):
     cleaned = "\n".join([line.strip() for line in text.splitlines() if line.strip()])
     return cleaned
 
-def truncate_awr_content(content, max_chars=90000):
-    if len(content) > max_chars:
-        return content[:max_chars] + "\n\n[TRUNCATED]"
-    return content
-
 # --- AWR Analyzer ---
-class AWRAnalyzer:
-    def __init__(self, model="gpt-4-turbo"):
-        self.model = model
+def analyze_awr(content, performance_test_mode, exadata_model, rack_size, selected_model_key):
+    cleaned_content = clean_awr_content(content)
+    max_chars = 128000
+    if len(cleaned_content) > max_chars:
+        cleaned_content = cleaned_content[:max_chars] + "\n\n[TRUNCATED]..."
 
-    def analyze(self, content, performance_test_mode, exadata_model, rack_size):
-        cleaned_content = clean_awr_content(content)
-        final_content = truncate_awr_content(cleaned_content)
+    # Build prompt
+    prompt = f"""
+You are an expert Oracle Database performance analyst with deep knowledge of AWR reports, Oracle RAC internals, and Exadata architecture (Smart Scan, Flash Cache, IORM, RDMA, Storage Indexes). 
+You must produce highly detailed diagnostic insights based on the AWR report provided below. Use numbers and thresholds whenever possible and explain why each observation matters. 
 
-        prompt = f"""
-You are an expert Oracle Database performance analyst with deep knowledge of AWR reports, Oracle RAC internals, and Exadata architecture (Smart Scan, Flash Cache, IORM, RDMA, Storage Indexes).
 ======== AWR REPORT START ========
-{final_content}
+{cleaned_content}
 ======== AWR REPORT END ========
 
-Please provide:
-- Performance Summary
-- Detailed Analysis of Bottlenecks and/or Degradation Risks
-- Performance Forecast and Predictions
-- Specific Recommendations for Monitoring
-- Exadata Statistics Performance Summary
-- Recommended Next Steps to Bridge Performance Gap
+Please provide the following sections:
+
+- **Performance Summary**
+- **Detailed Analysis of Bottlenecks and/or Degradation Risks**
+- **Performance Forecast and Predictions**
+- **Specific Recommendations for Monitoring**
+- **Exadata Statistics Performance Summary**
+- **Recommended Next Steps to Bridge Performance Gap**
 """
 
-        if performance_test_mode and exadata_model and rack_size:
-            specs = exadata_specs.get(exadata_model, {}).get(rack_size, {})
-            if specs:
-                prompt += f"""
+    # Add Exadata comparison if performance test mode
+    if performance_test_mode and exadata_model and rack_size:
+        specs = exadata_specs.get(exadata_model, {}).get(rack_size, {})
+        if specs:
+            prompt += f"""
 This was a PERFORMANCE TEST on Oracle Exadata {exadata_model} {rack_size}.
 Theoretical Max:
 - Max IOPS: {specs['max_iops']}
@@ -93,76 +91,88 @@ Theoretical Max:
 Show actual vs theoretical and generate Recommended Next Steps to Bridge Performance Gap.
 """
 
-        response = client.chat.completions.create(
-            model=self.model,
-            messages=[
-                {"role": "system", "content": "You are an expert Oracle Database performance analyst."},
-                {"role": "user", "content": prompt}
-            ]
-        )
-        return response.choices[0].message.content.strip()
-
-class Rater:
-    def __init__(self, model="mistral/ministral-8b"):
-        self.model = model
-
-    def rate(self, question, final_answer):
-        prompt = f"Rate this answer 1-5 stars with explanation:\n\n{final_answer}"
-        response = openai_rater.chat.completions.create(
-            model=self.model,
-            messages=[{"role": "user", "content": prompt}]
-        )
-        return response.choices[0].message.content.strip()
+    # Select model
+    model_choices = {
+        "GPT-4o (Balanced - Recommended for most tasks)": "gpt-4o",
+        "Claude 3 Opus (Best for Deep Diagnostic Analysis)": "claude-3-opus-20240229",
+        "GPT-4-turbo (Budget-Friendly, Good Quality)": "gpt-4-turbo",
+        "Claude 3 Sonnet (Good Balance, Lower Cost)": "claude-3-sonnet-20240229"
+    }
+
+    MODEL = model_choices.get(selected_model_key, "gpt-4o")  # Fallback to gpt-4o if invalid
+
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "system", "content": "You are an expert Oracle Database performance analyst."},
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return response.choices[0].message.content.strip()
+
+# --- Rater ---
+def rate_answer_rater(question, final_answer):
+    prompt = f"Rate this answer 1-5 stars with explanation:\n\n{final_answer}"
+    response = openai_rater.chat.completions.create(
+        model="mistral/ministral-8b",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content.strip()
+
+# --- Main Logic ---
+def process_awr(awr_text, correctness_threshold, performance_test_mode, exadata_model, rack_size, selected_model_key):
+    if not awr_text.strip():
+        return "No AWR report provided.", "", ""
+
+    answer = analyze_awr(awr_text, performance_test_mode, exadata_model, rack_size, selected_model_key)
+    rating_text = rate_answer_rater("AWR Analysis", answer)
+
+    stars = 0
+    match = re.search(r"(\d+)", rating_text)
+    if match:
+        stars = int(match.group(1))
+
+    if stars < correctness_threshold:
+        answer_retry = analyze_awr(awr_text, performance_test_mode, exadata_model, rack_size, selected_model_key)
+        rating_text_retry = rate_answer_rater("AWR Analysis (Retry)", answer_retry)
+
+        with open(log_filename, "a", encoding="utf-8") as log_file:
+            log_file.write(f"\n---\n{datetime.now()} RETRY\nOriginal: {answer}\nRating: {rating_text}\nRetry: {answer_retry}\nRetry Rating: {rating_text_retry}\n")
+
+        return answer_retry, rating_text_retry, "✅ Retry Occurred (rating below threshold)"
+    else:
+        with open(log_filename, "a", encoding="utf-8") as log_file:
+            log_file.write(f"\n---\n{datetime.now()} SUCCESS\nAnswer: {answer}\nRating: {rating_text}\n")
 
-# --- Gradio UI ---
-analyzer_agent = AWRAnalyzer()
-rater_agent = Rater()
+        return answer, rating_text, "✅ Accepted on first try"
 
+# --- Gradio UI ---
 with gr.Blocks() as demo:
-    gr.Markdown("## 📊 Oracle AWR Analyzer (with Truncation + Multi-Agent View)")
+    gr.Markdown("## 📊 Oracle AWR Analyzer (AI + Rating + Retry + Exadata Gap Analysis + Model Selection)")
 
-    awr_text = gr.Textbox(label="Paste AWR Report (HTML or TXT)", lines=30)
-    threshold = gr.Slider(0, 5, value=3, step=1, label="Correctness Threshold (Stars)")
+    awr_text = gr.Textbox(label="Paste AWR Report (HTML or TXT)", lines=30, placeholder="Paste full AWR here...")
+    threshold = gr.Slider(0, 5, value=3, step=1, label="Correctness Threshold (Stars for Retry)")
     performance_test_mode = gr.Checkbox(label="Performance Test Mode")
     exadata_model = gr.Dropdown(choices=["X7", "X8", "X9", "X10", "X11M"], label="Exadata Model", visible=False)
     rack_size = gr.Dropdown(choices=["Quarter Rack", "Half Rack", "Full Rack"], label="Rack Size", visible=False)
 
+    model_selector = gr.Dropdown(
+        choices=["GPT-4o (Balanced - Recommended for most tasks)", "Claude 3 Opus (Best for Deep Diagnostic Analysis)",
+                 "GPT-4-turbo (Budget-Friendly, Good Quality)", "Claude 3 Sonnet (Good Balance, Lower Cost)"],
+        label="Choose AI Model for Analysis",
+        value="GPT-4o (Balanced - Recommended for most tasks)"
+    )
+
     def toggle_visibility(mode):
         return gr.update(visible=mode), gr.update(visible=mode)
 
     performance_test_mode.change(toggle_visibility, inputs=performance_test_mode, outputs=[exadata_model, rack_size])
 
     analyze_btn = gr.Button("Analyze AWR")
-    output = gr.Textbox(label="AWR Analysis Result", lines=15)
+    output = gr.Textbox(label="AWR Analysis Result", lines=20)
     rating = gr.Textbox(label="Rater Rating + Explanation", lines=4)
     retry_status = gr.Textbox(label="Retry Status")
 
-    def process(awr_text, threshold, performance_test_mode, exadata_model, rack_size):
-        if not awr_text.strip():
-            return "No AWR report provided.", "", ""
-
-        answer = analyzer_agent.analyze(awr_text, performance_test_mode, exadata_model, rack_size)
-        rating_text = rater_agent.rate("AWR Analysis", answer)
-
-        stars = 0
-        match = re.search(r"(\d+)", rating_text)
-        if match:
-            stars = int(match.group(1))
-
-        if stars < threshold:
-            retry_answer = analyzer_agent.analyze(awr_text, performance_test_mode, exadata_model, rack_size)
-            retry_rating = rater_agent.rate("AWR Analysis Retry", retry_answer)
-
-            with open(log_filename, "a", encoding="utf-8") as log_file:
-                log_file.write(f"\n---\n{datetime.now()} RETRY\nOriginal: {answer}\nRating: {rating_text}\nRetry: {retry_answer}\nRetry Rating: {retry_rating}\n")
-
-            return retry_answer, retry_rating, "✅ Retry Occurred"
-        else:
-            with open(log_filename, "a", encoding="utf-8") as log_file:
-                log_file.write(f"\n---\n{datetime.now()} SUCCESS\nAnswer: {answer}\nRating: {rating_text}\n")
-
-            return answer, rating_text, "✅ Accepted on first try"
-
-    analyze_btn.click(process, inputs=[awr_text, threshold, performance_test_mode, exadata_model, rack_size], outputs=[output, rating, retry_status])
+    analyze_btn.click(process_awr, inputs=[awr_text, threshold, performance_test_mode, exadata_model, rack_size, model_selector], outputs=[output, rating, retry_status])
 
-    demo.launch(debug=True)
+demo.launch(debug=True)