Update app.py

app.py

@@ -1,117 +1,197 @@
-import gradio as gr
-import time
+import os
 import random
-import requests
+import json
+import time
 import numpy as np
 import pandas as pd
-import faiss
+import requests
+from datetime import datetime
+from sklearn.metrics.pairwise import cosine_similarity
 from sentence_transformers import SentenceTransformer
+import gradio as gr
 
-# --- CONFIG ---
-HF_TOKEN = (open(".env", "r").read().strip() if ".env" else None) or ""
-HF_TOKEN = HF_TOKEN.strip() if HF_TOKEN else ""
-if not HF_TOKEN:
-    print("⚠️ No Hugging Face token found. Running in fallback mode (local inference).")
-
-API_URL = "https://router.huggingface.co/hf-inference"
+# ============================
+# SAFE TOKEN LOAD
+# ============================
+HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
+if not HF_TOKEN and os.path.exists(".env"):
+    try:
+        with open(".env", "r") as f:
+            HF_TOKEN = f.read().strip()
+    except Exception:
+        HF_TOKEN = ""
+
+if HF_TOKEN:
+    print("✅ Hugging Face token loaded successfully.")
+else:
+    print("⚠️ No Hugging Face token found. Running in fallback/local mode.")
+
+# ============================
+# GLOBAL CONFIG
+# ============================
+HF_API_URL = "https://router.huggingface.co/hf-inference"
+headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+
+# Load a lightweight sentence transformer for embedding incidents
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+# Vector memory store (in-memory for now)
+incident_memory = []
+
+# ============================
+# ANOMALY DETECTION
+# ============================
+def detect_anomaly(event):
+    """
+    Detects anomalies based on latency/error_rate thresholds.
+    Forces an anomaly randomly for validation.
+    """
+    force_anomaly = random.random() < 0.25  # ~25% forced anomaly rate
+    if force_anomaly or event["latency"] > 150 or event["error_rate"] > 0.05:
+        return True
+    return False
+
+
+# ============================
+# AI ANALYSIS + HEALING
+# ============================
+def analyze_event(event):
+    """
+    Send event to HF Inference API for analysis, fallback locally if needed.
+    """
+    prompt = (
+        f"Analyze this telemetry event and suggest a healing action:\n"
+        f"Component: {event['component']}\n"
+        f"Latency: {event['latency']}\n"
+        f"Error Rate: {event['error_rate']}\n"
+        f"Detected Anomaly: {event['anomaly']}\n"
+    )
+
+    if not HF_TOKEN:
+        return "Local mode: analysis unavailable (no token).", "No action taken."
 
-model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
-incident_embeddings = []
-incident_texts = []
+    try:
+        response = requests.post(
+            f"{HF_API_URL}/mistralai/Mixtral-8x7B-Instruct-v0.1",
+            headers=headers,
+            json={"inputs": prompt},
+            timeout=10,
+        )
+        if response.status_code == 200:
+            result = response.json()
+            text = (
+                result[0]["generated_text"]
+                if isinstance(result, list) and "generated_text" in result[0]
+                else str(result)
+            )
+            return text, choose_healing_action(event, text)
+        else:
+            return f"Error {response.status_code}: {response.text}", "No actionable step detected."
+    except Exception as e:
+        return f"Error generating analysis: {e}", "No actionable step detected."
 
-recent_events = []
 
-# --- SIMULATION HELPERS ---
-def simulate_healing_action(component: str) -> str:
-    actions = [
+# ============================
+# HEALING SIMULATION
+# ============================
+def choose_healing_action(event, analysis_text):
+    """Simulates an automated healing response."""
+    possible_actions = [
         "Restarted container",
+        "Scaled service replicas",
         "Cleared queue backlog",
-        "Rebalanced load",
-        "No actionable step detected.",
-    ]
-    return random.choice(actions)
-
-def detect_anomaly(latency: float, error_rate: float) -> bool:
-    # Simple adaptive anomaly threshold
-    score = latency * error_rate
-    threshold = random.uniform(5, 25)
-    return score > threshold
-
-def embed_incident(text: str):
-    emb = model.encode([text], normalize_embeddings=True)
-    return np.array(emb).astype("float32")
-
-def find_similar_incidents(new_text: str, top_k=3):
-    if not incident_embeddings:
-        return "Not enough incidents stored yet."
-    new_emb = embed_incident(new_text)
-    index = faiss.IndexFlatIP(len(new_emb[0]))
-    index.add(np.vstack(incident_embeddings))
-    scores, ids = index.search(new_emb, top_k)
-    similar = [
-        f"Component: {incident_texts[i]['component']} | Latency: {incident_texts[i]['latency']} | ErrorRate: {incident_texts[i]['error_rate']} | Analysis: {incident_texts[i]['analysis'][:60]}..."
-        for i in ids[0] if i < len(incident_texts)
+        "Invalidated cache",
+        "Re-deployed model endpoint",
     ]
-    return f"Found {len(similar)} similar incidents ({'; '.join(similar)})."
+    if "restart" in analysis_text.lower():
+        return "Restarted container"
+    elif "scale" in analysis_text.lower():
+        return "Scaled service replicas"
+    elif "cache" in analysis_text.lower():
+        return "Invalidated cache"
+    return random.choice(possible_actions)
+
+
+# ============================
+# VECTOR SIMILARITY ENGINE
+# ============================
+def record_and_search_similar(event, analysis_text):
+    """
+    Store each event as a vector and retrieve similar past incidents.
+    """
+    description = (
+        f"Component: {event['component']} | "
+        f"Latency: {event['latency']} | "
+        f"ErrorRate: {event['error_rate']} | "
+        f"Analysis: {analysis_text}"
+    )
+    embedding = model.encode(description)
+
+    similar_info = ""
+    if incident_memory:
+        existing_embeddings = np.array([e["embedding"] for e in incident_memory])
+        sims = cosine_similarity([embedding], existing_embeddings)[0]
+        top_indices = sims.argsort()[-3:][::-1]
+        similar = [
+            incident_memory[i]["description"]
+            for i in top_indices
+            if sims[i] > 0.7
+        ]
+        if similar:
+            similar_info = f"Found {len(similar)} similar incidents (e.g., {similar[0][:150]}...)."
+
+    incident_memory.append({"embedding": embedding, "description": description})
+    return similar_info
+
+
+# ============================
+# EVENT HANDLER
+# ============================
+event_log = []
 
-# --- MAIN PROCESS ---
 def process_event(component, latency, error_rate):
-    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-    anomaly = detect_anomaly(latency, error_rate)
-
-    # --- Analysis step ---
-    payload = {
-        "inputs": f"Component {component} showing latency {latency} and error rate {error_rate}.",
-    }
-
-    try:
-        headers = {"Authorization": f"Bearer {HF_TOKEN.strip()}"}
-        response = requests.post(f"{API_URL}/facebook/bart-large-mnli", headers=headers, json=payload)
-        if response.status_code == 200:
-            analysis = response.json().get("generated_text", "No analysis output.")
-        else:
-            analysis = f"Error {response.status_code}: {response.text}"
-    except Exception as e:
-        analysis = f"Error generating analysis: {str(e)}"
-
-    status = "Anomaly" if anomaly else "Normal"
-    healing_action = simulate_healing_action(component) if anomaly else "-"
-    similar_info = find_similar_incidents(analysis)
-
     event = {
-        "timestamp": timestamp,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         "component": component,
         "latency": latency,
         "error_rate": error_rate,
-        "status": status,
-        "analysis": analysis,
-        "healing_action": f"{healing_action} {similar_info}" if anomaly else f"- {similar_info}",
     }
+    event["anomaly"] = detect_anomaly(event)
+    status = "Anomaly" if event["anomaly"] else "Normal"
+    analysis, healing = analyze_event(event)
+    similar = record_and_search_similar(event, analysis)
+    healing = f"{healing} {similar}".strip()
 
-    recent_events.append(event)
-    if len(recent_events) > 20:
-        recent_events.pop(0)
+    event["status"] = status
+    event["analysis"] = analysis
+    event["healing_action"] = healing
+    event_log.append(event)
 
-    # --- Store vector memory ---
-    incident_embeddings.append(embed_incident(analysis))
-    incident_texts.append(event)
+    df = pd.DataFrame(event_log[-20:])
+    return f"✅ Event Processed ({status})", df
 
-    return f"✅ Event Processed", pd.DataFrame(recent_events)
 
-# --- GRADIO UI ---
+# ============================
+# GRADIO UI
+# ============================
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("## 🧠 Agentic Reliability Framework MVP")
-    gr.Markdown("Adaptive anomaly detection + AI-driven self-healing + vector memory")
+    gr.Markdown(
+        "Adaptive anomaly detection + AI-driven self-healing + vector memory"
+    )
 
-    with gr.Row():
-        component = gr.Textbox(label="Component", value="api-service")
-        latency = gr.Number(label="Latency (ms)", value=random.uniform(50, 200))
-        error_rate = gr.Number(label="Error Rate", value=random.uniform(0.01, 0.2))
+    component = gr.Textbox(label="Component", value="api-service")
+    latency = gr.Slider(10, 400, value=100, label="Latency (ms)")
+    error_rate = gr.Slider(0.0, 0.2, value=0.02, label="Error Rate")
 
-    submit = gr.Button("🚀 Submit Telemetry Event")
-    output_text = gr.Textbox(label="Detection Output")
-    output_table = gr.Dataframe(headers=["timestamp", "component", "latency", "error_rate", "status", "analysis", "healing_action"], label="Recent Events (Last 20)")
+    submit = gr.Button("🚀 Submit Telemetry Event", variant="primary")
+    output = gr.Textbox(label="Detection Output")
+    table = gr.Dataframe(label="Recent Events (Last 20)")
 
-    submit.click(process_event, inputs=[component, latency, error_rate], outputs=[output_text, output_table])
+    submit.click(process_event, [component, latency, error_rate], [output, table])
 
-demo.launch()
+# ============================
+# ENTRY POINT
+# ============================
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)