Update app.py

app.py

@@ -8,10 +8,21 @@ from bs4 import BeautifulSoup
 
 # --- API Keys ---
 openai_api_key = os.environ.get("OPENAI_API_KEY")
+openrouter_key = os.environ.get("OPENROUTER")
+
 if not openai_api_key:
     raise ValueError("OPENAI_API_KEY environment variable is not set.")
+if not openrouter_key:
+    raise ValueError("OPENROUTER environment variable is not set.")
 
 client = openai.OpenAI(api_key=openai_api_key)
+openai_rater = openai.OpenAI(api_key=openrouter_key, base_url="https://openrouter.ai/api/v1")
+
+# --- Logger ---
+log_filename = "rating_log.txt"
+if not os.path.exists(log_filename):
+    with open(log_filename, "w", encoding="utf-8") as f:
+        f.write("=== Rating Log Initialized ===\n")
 
 # --- Exadata Specs ---
 exadata_specs = {
@@ -42,98 +53,76 @@ 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
 
-# --- Agent Classes ---
-
-SYSTEM_PROMPT = """
-You are an expert Oracle Exadata and RAC performance consultant.
-Prioritize CRITICAL SYSTEM HEALTH issues first. Provide DBA-level observations and recommendations.
-"""
-
-class HealthRiskAgent:
-    def __init__(self, model="gpt-4o"):
+# --- AWR Analyzer ---
+class AWRAnalyzer:
+    def __init__(self, model="gpt-4-turbo"):
         self.model = model
 
-    def analyze(self, data):
-        prompt = f"""
-======== BEGIN DATA ========
-{data}
-======== END DATA ========
-
-Identify CRITICAL SYSTEM HEALTH issues (Flash Cache degraded, Confined Disks, Redo Stress, RAC GC waits, IO Errors). 
-If issues found, output "⚠️ CRITICAL ALERTS DETECTED" + Explanation + DBA Actions.
-If clean, output "✅ None Detected".
-"""
-        response = client.chat.completions.create(
-            model=self.model,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": prompt}
-            ]
-        )
-        return response.choices[0].message.content.strip()
-
+    def analyze(self, content, performance_test_mode, exadata_model, rack_size):
+        cleaned_content = clean_awr_content(content)
+        final_content = truncate_awr_content(cleaned_content)
 
-class PerformanceAnalyzerAgent:
-    def __init__(self, model="gpt-4o"):
-        self.model = model
-
-    def analyze(self, data, exadata_model=None, rack_size=None):
         prompt = f"""
-======== BEGIN DATA ========
-{data}
-======== END DATA ========
+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}
+======== AWR REPORT END ========
 
 Please provide:
 - Performance Summary
-- Detailed Bottleneck Analysis
-- Forecast / Predictions
-- Monitoring Suggestions
-- Exadata Stats Summary
-- Recommended Next Steps
-
-If this is a performance test:
-- Compare observed vs theoretical for Exadata
-- Recommend gap-closing actions.
+- 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 exadata_model and rack_size:
+
+        if performance_test_mode and exadata_model and rack_size:
             specs = exadata_specs.get(exadata_model, {}).get(rack_size, {})
             if specs:
                 prompt += f"""
-Theoretical Max for Oracle Exadata {exadata_model} {rack_size}:
+This was a PERFORMANCE TEST on Oracle Exadata {exadata_model} {rack_size}.
+Theoretical Max:
 - Max IOPS: {specs['max_iops']}
 - Max Throughput: {specs['max_throughput']} GB/s
+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": SYSTEM_PROMPT},
+                {"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
 
-class AWRAgentCoordinator:
-    def __init__(self):
-        self.health_agent = HealthRiskAgent()
-        self.performance_agent = PerformanceAnalyzerAgent()
-
-    def analyze(self, awr_data, exadata_model=None, rack_size=None):
-        # Run both agents
-        health_result = self.health_agent.analyze(awr_data)
-        perf_result = self.performance_agent.analyze(awr_data, exadata_model, rack_size)
-
-        return health_result, perf_result
-
+    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()
 
 # --- Gradio UI ---
-agent = AWRAgentCoordinator()
+analyzer_agent = AWRAnalyzer()
+rater_agent = Rater()
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 📊 Exadata + RAC AWR Analyzer (Multi-Agent View)")
+    gr.Markdown("## 📊 Oracle AWR Analyzer (with Truncation + Multi-Agent View)")
 
-    awr_text = gr.Textbox(label="Paste AWR Report (HTML or TXT)", lines=30, placeholder="Paste AWR report here...")
+    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)")
     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)
@@ -143,26 +132,37 @@ with gr.Blocks() as demo:
 
     performance_test_mode.change(toggle_visibility, inputs=performance_test_mode, outputs=[exadata_model, rack_size])
 
-    analyze_btn = gr.Button("Analyze AWR Report")
-
-    with gr.Row():
-        health_output = gr.Textbox(label="Health Risk Agent (Critical Alerts + Actions)", lines=20)
-        performance_output = gr.Textbox(label="Performance Analyzer Agent (Full Analysis)", lines=20)
+    analyze_btn = gr.Button("Analyze AWR")
+    output = gr.Textbox(label="AWR Analysis Result", lines=15)
+    rating = gr.Textbox(label="Rater Rating + Explanation", lines=4)
+    retry_status = gr.Textbox(label="Retry Status")
 
-    def run_analysis(awr_text, performance_test_mode, exadata_model, rack_size):
+    def process(awr_text, threshold, performance_test_mode, exadata_model, rack_size):
         if not awr_text.strip():
-            return "❗ Please paste the AWR report first.", ""
+            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)
 
-        cleaned = clean_awr_content(awr_text)
+            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")
 
-        if performance_test_mode:
-            health, perf = agent.analyze(cleaned, exadata_model, rack_size)
+            return retry_answer, retry_rating, "✅ Retry Occurred"
         else:
-            health, perf = agent.analyze(cleaned)
+            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 health, perf
+            return answer, rating_text, "✅ Accepted on first try"
 
-    analyze_btn.click(run_analysis, inputs=[awr_text, performance_test_mode, exadata_model, rack_size],
-                      outputs=[health_output, performance_output])
+    analyze_btn.click(process, inputs=[awr_text, threshold, performance_test_mode, exadata_model, rack_size], outputs=[output, rating, retry_status])
 
-demo.launch(debug=True)
+    demo.launch(debug=True)