Update hf_demo.py

hf_demo.py

@@ -1,10 +1,19 @@
-# hf_demo.py – ARF v4 API (Minimal Working Version)
-from fastapi import FastAPI
+# hf_demo.py – ARF v4 API with Memory
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 import gradio as gr
+import numpy as np
+from datetime import datetime
+
+# ARF v4 imports
 from agentic_reliability_framework.core.governance.risk_engine import RiskEngine
+from agentic_reliability_framework.runtime.memory import (
+    create_faiss_index,
+    RAGGraphMemory,
+    MemoryConstants
+)
 
-app = FastAPI(title="ARF v4 API")
+app = FastAPI(title="ARF v4 API with Memory")
 
 # Enable CORS for your frontend
 app.add_middleware(
@@ -13,9 +22,28 @@ app.add_middleware(
     allow_methods=["*"],
 )
 
-# Initialize RiskEngine only
+# ---------------------------------------------------------------------------
+# Initialize ARF components
+# ---------------------------------------------------------------------------
 risk_engine = RiskEngine()
 
+# Create FAISS index and memory (using default dimension from constants)
+faiss_index = create_faiss_index(dim=MemoryConstants.VECTOR_DIM)
+memory = RAGGraphMemory(faiss_index)
+
+# ---------------------------------------------------------------------------
+# API Endpoints
+# ---------------------------------------------------------------------------
+
+@app.get("/")
+async def root():
+    return {
+        "service": "ARF OSS API",
+        "version": "4.0.0",
+        "status": "operational",
+        "memory_stats": memory.get_graph_stats() if memory.has_historical_data() else "empty"
+    }
+
 @app.get("/health")
 async def health():
     return {"status": "ok", "version": "4.0.0"}
@@ -29,6 +57,59 @@ async def get_risk():
         "status": "critical" if risk_score.mean > 0.8 else "normal"
     }
 
+@app.post("/api/v1/incident")
+async def store_incident(event_data: dict, analysis: dict):
+    """
+    Store an incident in memory.
+    event_data should contain at least 'component', 'latency_p99', 'error_rate', etc.
+    """
+    # In a real implementation you would parse a ReliabilityEvent.
+    # For simplicity, we pass a dict – you may need to adapt.
+    try:
+        incident_id = memory.store_incident(event_data, analysis)
+        return {"incident_id": incident_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/v1/memory/similar")
+async def find_similar_incidents(action: str, k: int = 5):
+    """
+    Find incidents similar to the given action text.
+    This uses a simple embedding fallback (random) for OSS.
+    For production, integrate sentence-transformers.
+    """
+    # Create a dummy event from the action text
+    class DummyEvent:
+        def __init__(self, action):
+            self.component = "user_action"
+            self.latency_p99 = 0.0
+            self.error_rate = 0.0
+            self.throughput = 0
+            self.cpu_util = 0.0
+            self.memory_util = 0.0
+            self.timestamp = datetime.now()
+            self.severity = "low"
+    event = DummyEvent(action)
+    analysis = {"action": action}
+    similar = memory.find_similar(event, analysis, k=k)
+    # Convert nodes to dict
+    results = []
+    for node in similar:
+        results.append({
+            "incident_id": node.incident_id,
+            "component": node.component,
+            "severity": node.severity,
+            "timestamp": node.timestamp,
+            "metrics": node.metrics,
+            "agent_analysis": node.agent_analysis,
+            "similarity_score": node.metadata.get("similarity_score", 0.0)
+        })
+    return {"similar": results, "count": len(results)}
+
+@app.get("/api/v1/memory/stats")
+async def memory_stats():
+    return memory.get_graph_stats()
+
 # Optional Gradio interface
 iface = gr.Interface(
     fn=lambda: f"ARF v4 - Current risk: {risk_engine.get_current_risk().mean:.2f}",