Update app.py

app.py

@@ -3,13 +3,21 @@ import asyncio
 import json
 import logging
 import traceback
+import random
+from datetime import datetime
+
+# Import the base engine
 from agentic_reliability_framework.runtime.engine import EnhancedReliabilityEngine
 
-# Configure logging to show details
+# Import our new AI components
+from ai_event import AIEvent
+from hallucination_detective import HallucinationDetectiveAgent
+from memory_drift_diagnostician import MemoryDriftDiagnosticianAgent
+
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Initialize the engine
+# Initialize the engine (for infrastructure analysis)
 try:
     logger.info("Initializing EnhancedReliabilityEngine...")
     engine = EnhancedReliabilityEngine()
@@ -18,12 +26,15 @@ except Exception as e:
     logger.error(f"Failed to initialize engine: {e}\n{traceback.format_exc()}")
     engine = None
 
-async def analyze(component, latency, error_rate, throughput, cpu_util, memory_util):
-    """Call the ARF v4 engine with telemetry data."""
+# AI agents (initialize once)
+hallucination_detective = HallucinationDetectiveAgent()
+memory_drift_diagnostician = MemoryDriftDiagnosticianAgent()
+
+async def analyze_infrastructure(component, latency, error_rate, throughput, cpu_util, memory_util):
+    """Original infrastructure analysis."""
     if engine is None:
         return json.dumps({"error": "Engine failed to initialize. Check logs."}, indent=2)
     try:
-        logger.info(f"Analyzing: component={component}, latency={latency}, error_rate={error_rate}, throughput={throughput}, cpu={cpu_util}, mem={memory_util}")
         result = await engine.process_event_enhanced(
             component=component,
             latency=float(latency),
@@ -32,57 +43,109 @@ async def analyze(component, latency, error_rate, throughput, cpu_util, memory_u
             cpu_util=float(cpu_util) if cpu_util else None,
             memory_util=float(memory_util) if memory_util else None
         )
-        logger.info("Analysis completed successfully.")
         return json.dumps(result, indent=2)
     except Exception as e:
-        logger.error(f"Error during analysis: {e}\n{traceback.format_exc()}")
+        logger.error(f"Infrastructure analysis error: {e}\n{traceback.format_exc()}")
         return json.dumps({"error": str(e), "traceback": traceback.format_exc()}, indent=2)
 
-def sync_analyze(*args):
-    """Synchronous wrapper for Gradio."""
-    return asyncio.run(analyze(*args))
+async def analyze_ai(component, prompt, model_name, model_version, confidence, perplexity, retrieval_score):
+    """AI reliability analysis."""
+    try:
+        # Simulate a response (in a real app, call an actual model)
+        response = f"Mock response to: {prompt}"
+        # Create AIEvent
+        event = AIEvent(
+            timestamp=datetime.utcnow(),
+            component=component,
+            service_mesh="ai",
+            latency_p99=random.uniform(100, 500),
+            error_rate=0.0,
+            throughput=1,
+            cpu_util=None,
+            memory_util=None,
+            model_name=model_name,
+            model_version=model_version,
+            prompt=prompt,
+            response=response,
+            response_length=len(response),
+            confidence=confidence,
+            perplexity=perplexity,
+            retrieval_scores=[retrieval_score],
+            user_feedback=None,
+            latency_ms=random.uniform(200, 800)
+        )
+        # Run agents
+        hallu_result = await hallucination_detective.analyze(event)
+        drift_result = await memory_drift_diagnostician.analyze(event)
+        # Combine results
+        result = {
+            "hallucination_detection": hallu_result,
+            "memory_drift_detection": drift_result,
+            "response": response
+        }
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"AI analysis error: {e}\n{traceback.format_exc()}")
+        return json.dumps({"error": str(e), "traceback": traceback.format_exc()}, indent=2)
 
-# Define the Gradio interface
+def sync_infrastructure(*args):
+    return asyncio.run(analyze_infrastructure(*args))
+
+def sync_ai(*args):
+    return asyncio.run(analyze_ai(*args))
+
+# Build the Gradio interface with tabs
 with gr.Blocks(title="ARF v4 – Reliability Lab", theme="soft") as demo:
-    gr.Markdown("""
-    # 🧠 Agentic Reliability Framework v4
-    **Hybrid Bayesian + HMC intelligence for infrastructure reliability**
-    
-    Enter telemetry below to see ARF's advisory analysis. All outputs are **OSS advisory only** – no execution.
-    """)
+    gr.Markdown("# 🧠 Agentic Reliability Framework v4\n**Infrastructure & AI Reliability**")
     
-    with gr.Row():
-        with gr.Column():
-            component = gr.Dropdown(
-                choices=["api-service", "auth-service", "payment-service", "database", "cache-service"],
-                value="api-service",
-                label="Component"
+    with gr.Tabs():
+        with gr.TabItem("Infrastructure"):
+            gr.Markdown("Enter telemetry to analyze infrastructure incidents.")
+            with gr.Row():
+                with gr.Column():
+                    component = gr.Dropdown(
+                        choices=["api-service", "auth-service", "payment-service", "database", "cache-service"],
+                        value="api-service", label="Component"
+                    )
+                    latency = gr.Slider(10, 1000, value=100, label="Latency P99 (ms)")
+                    error_rate = gr.Slider(0, 0.5, value=0.02, step=0.001, label="Error Rate")
+                    throughput = gr.Number(value=1000, label="Throughput (req/s)")
+                    cpu_util = gr.Slider(0, 1, value=0.4, label="CPU Utilization")
+                    memory_util = gr.Slider(0, 1, value=0.3, label="Memory Utilization")
+                    infra_submit = gr.Button("Analyze Infrastructure", variant="primary")
+                with gr.Column():
+                    infra_output = gr.JSON(label="Analysis Result")
+            infra_submit.click(
+                fn=sync_infrastructure,
+                inputs=[component, latency, error_rate, throughput, cpu_util, memory_util],
+                outputs=infra_output
             )
-            latency = gr.Slider(10, 1000, value=100, label="Latency P99 (ms)")
-            error_rate = gr.Slider(0, 0.5, value=0.02, step=0.001, label="Error Rate")
-            throughput = gr.Number(value=1000, label="Throughput (req/s)")
-            cpu_util = gr.Slider(0, 1, value=0.4, label="CPU Utilization")
-            memory_util = gr.Slider(0, 1, value=0.3, label="Memory Utilization")
-            submit = gr.Button("🚀 Analyze", variant="primary")
         
-        with gr.Column():
-            output = gr.JSON(label="ARF Analysis Result")
-    
-    submit.click(
-        fn=sync_analyze,
-        inputs=[component, latency, error_rate, throughput, cpu_util, memory_util],
-        outputs=output
-    )
+        with gr.TabItem("AI Reliability"):
+            gr.Markdown("Simulate an AI query to detect hallucinations and memory drift.")
+            with gr.Row():
+                with gr.Column():
+                    ai_component = gr.Dropdown(
+                        choices=["chat", "code", "summary"], label="Task Type", value="chat"
+                    )
+                    prompt = gr.Textbox(label="Prompt", value="What is the capital of France?")
+                    model_name = gr.Dropdown(["gpt-3.5", "gpt-4", "claude"], label="Model", value="gpt-4")
+                    model_version = gr.Textbox(value="v1", label="Version")
+                    confidence = gr.Slider(0, 1, value=0.95, label="Model Confidence")
+                    perplexity = gr.Slider(0, 50, value=5, label="Perplexity")
+                    retrieval_score = gr.Slider(0, 1, value=0.8, label="Retrieval Score")
+                    ai_submit = gr.Button("Analyze AI", variant="primary")
+                with gr.Column():
+                    ai_output = gr.JSON(label="Analysis Result")
+            ai_submit.click(
+                fn=sync_ai,
+                inputs=[ai_component, prompt, model_name, model_version, confidence, perplexity, retrieval_score],
+                outputs=ai_output
+            )
     
     gr.Markdown("""
     ---
-    ### 📚 About This Demo
-    - Uses the full **ARF v4 engine** (`EnhancedReliabilityEngine`)
-    - Risk scores combine **online conjugate priors** + **offline HMC** (if trained)
-    - Multi‑agent system runs in parallel (detective, diagnostician, predictive)
-    - Optional Claude synthesis (if `ANTHROPIC_API_KEY` is set)
-    
-    [📖 Tutorial](https://github.com/petter2025us/agentic-reliability-framework/blob/main/TUTORIAL.md) | 
+    [📖 Tutorial](https://github.com/petter2025us/agentic-reliability-framework/blob/main/TUTORIAL.md) |
     [🐙 GitHub](https://github.com/petter2025us/agentic-reliability-framework) |
     [💼 Enterprise](mailto:petter2025us@outlook.com)
     """)