Upload 6 files

README.md

@@ -1,11 +1,2 @@
----
-title: PAM UmiNur
-emoji: 🌍
-colorFrom: yellow
-colorTo: purple
-sdk: docker
-pinned: false
-short_description: PAM V1
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PAM-UmiNur
+Private AI assistant powered by Hugging Face Inference API. Integrates frontend + backend secure logic for UmiNur health platform.

api_service.py

@@ -0,0 +1,92 @@
+# filename: api_service.py
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Dict, Any, Optional
+
+# Import the core logic and model loading functions
+from backend_pam import load_agent as load_backend_agent, PAM
+from frontend_pam import load_frontend_agent, FrontendPAM
+
+# --- Global Agent Variables ---
+backend_agent: Optional[PAM] = None
+frontend_agent: Optional[FrontendPAM] = None
+
+# --- Data Model for API Request ---
+class UserInput(BaseModel):
+    user_input: str
+
+# --- FastAPI Initialization ---
+app = FastAPI(
+    title="PAM Unified Inference Service (Technical & Chat)",
+    version="2.0.0",
+    docs_url=None,
+    redoc_url=None
+)
+
+# --- CORS Setup ---
+origins = [
+    "https://www.uminur.app",
+    "https://api.uminur.app",
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["POST", "GET"],
+    allow_headers=["*"],
+)
+
+# --- Startup Event ---
+@app.on_event("startup")
+async def startup_event():
+    global backend_agent, frontend_agent
+    print("FastAPI: Starting up PAM agents...")
+
+    backend_agent = load_backend_agent()
+    frontend_agent = load_frontend_agent()
+
+    if not backend_agent or not frontend_agent:
+        print("FastAPI: ERROR — One or both agents failed to initialize.")
+
+# --- Health Check ---
+@app.get("/health", status_code=200, tags=["Status"])
+def health_check():
+    backend_ok = backend_agent is not None
+    frontend_ok = frontend_agent is not None
+
+    if backend_ok and frontend_ok:
+        return {"status": "ok", "backend_ready": True, "frontend_ready": True}
+
+    raise HTTPException(
+        status_code=503,
+        detail=f"Service Unavailable: Backend Ready: {backend_ok}, Frontend Ready: {frontend_ok}"
+    )
+
+# --- Technical Endpoint ---
+@app.post("/ai/technical/", tags=["Technical"])
+async def technical_endpoint(input_data: UserInput) -> Dict[str, Any]:
+    if backend_agent is None:
+        raise HTTPException(status_code=503, detail="Backend PAM is not initialized.")
+
+    try:
+        pam_reply = backend_agent.process_input(input_data.user_input)
+        return pam_reply
+    except Exception as e:
+        print(f"Error during technical inference: {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error (technical)")
+
+# --- Chat Endpoint ---
+@app.post("/ai/chat/", tags=["Chat"])
+async def chat_endpoint(input_data: UserInput) -> Dict[str, Any]:
+    if frontend_agent is None:
+        raise HTTPException(status_code=503, detail="Frontend PAM is not initialized.")
+
+    try:
+        pam_reply = frontend_agent.respond(input_data.user_input)
+        return pam_reply
+    except Exception as e:
+        print(f"Error during chat inference: {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error (chat)")

app.py

@@ -0,0 +1,6 @@
+# app.py
+import uvicorn
+from api_service import app
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

backend_pam.py

@@ -0,0 +1,204 @@
+# filename: backend_pam.py (UPDATED FOR INFERENCE API)
+
+from transformers import pipeline, HuggingFaceHub
+from datetime import datetime
+from typing import Dict, Any, Optional
+import json
+import os
+
+# --- Constants for Data Paths ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+LOGS_FILE = os.path.join(DATA_DIR, "logs.json")
+COMPLIANCE_FILE = os.path.join(DATA_DIR, "compliance.json")
+
+# --- Global Storage for Loaded Components ---
+LOADED_MODELS = None
+LOADED_DATA = None
+
+# --- Data Loading Helper ---
+def load_json(filepath: str) -> Dict[str, Any]:
+    try:
+        with open(filepath, 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"CRITICAL: Data file not found at: {filepath}")
+        return {}
+    except json.JSONDecodeError as e:
+        print(f"CRITICAL: Failed to decode JSON from {filepath}: {e}")
+        return {}
+
+# --- Agent Initialization ---
+def load_agent() -> 'PAM':
+    global LOADED_MODELS, LOADED_DATA
+
+    if LOADED_MODELS is not None:
+        print("PAM agent already loaded. Skipping reinit.")
+        return PAM(LOADED_MODELS, LOADED_DATA)
+
+    print("Loading PAM technical assistant models from Hugging Face Inference API...")
+
+    HUGGING_FACE_TOKEN = os.getenv("HF_READ_TOKEN")
+    if not HUGGING_FACE_TOKEN:
+        print("FATAL: HF_READ_TOKEN not set in environment. PAM will fail to load.")
+
+    try:
+        models = {
+            "phi_ner": pipeline(
+                "ner",
+                model=HuggingFaceHub(repo_id="Jean-Baptiste/roberta-large-ner-english", token=HUGGING_FACE_TOKEN),
+                aggregation_strategy="simple"
+            ),
+            "log_ner": pipeline(
+                "ner",
+                model=HuggingFaceHub(repo_id="dslim/bert-base-NER", token=HUGGING_FACE_TOKEN),
+                aggregation_strategy="simple"
+            ),
+            "summarizer": pipeline(
+                "summarization",
+                model=HuggingFaceHub(repo_id="google/flan-t5-large", token=HUGGING_FACE_TOKEN)
+            )
+        }
+        print("✅ All PAM models loaded via Hugging Face Inference API.")
+        LOADED_MODELS = models
+    except Exception as e:
+        print(f"FATAL: Could not load inference models. {e}")
+        LOADED_MODELS = None
+
+    data = {
+        "LOGS": load_json(LOGS_FILE),
+        "COMPLIANCE": load_json(COMPLIANCE_FILE)
+    }
+
+    if not data["LOGS"] or not data["COMPLIANCE"]:
+        print("❌ WARNING: Log or compliance data failed to load.")
+    else:
+        print("✅ Log & compliance data loaded.")
+
+    LOADED_DATA = data
+    return PAM(LOADED_MODELS, LOADED_DATA)
+
+# --- Helper: classify severity ---
+def classify_severity(entry: str) -> str:
+    entry_lower = entry.lower()
+    if any(x in entry_lower for x in ["unauthorized", "failed", "attack", "port scanning", "unavailable"]):
+        return "CRITICAL"
+    elif any(x in entry_lower for x in ["warning", "unexpected", "outside working hours"]):
+        return "WARNING"
+    else:
+        return "INFO"
+
+# --- PAM Role ---
+PAM_ROLE = (
+    "I am PAM, your technical assistant and infrastructure watchdog. "
+    "I summarize logs, detect risks, and support developers with clarity. "
+    "I flag anomalies, monitor compliance, and hand off client-facing issues when needed. "
+    "I never act on my own, always permission first, protocol always."
+)
+
+# --- Backend PAM Class ---
+class PAM:
+    def __init__(self, models: Optional[Dict[str, Any]], data: Dict[str, Dict]):
+        self.phi_detector = models.get("phi_ner") if models else None
+        self.log_parser = models.get("log_ner") if models else None
+        self.summarizer = models.get("summarizer") if models else None
+        self.LOGS = data.get("LOGS", {})
+        self.COMPLIANCE = data.get("COMPLIANCE", {})
+
+    def _check_activation(self, text: str) -> Optional[str]:
+        if not self.phi_detector:
+            return "Fatal Error: PAM models failed to load on startup. 🛠️"
+        return None
+
+    def detect_phi(self, text: str) -> Dict[str, Any]:
+        error = self._check_activation(text)
+        if error:
+            return {"message": error, "role": PAM_ROLE}
+
+        entities = self.phi_detector(text)
+        phi = [e for e in entities if e["entity_group"] in ["PER", "LOC", "ORG", "DATE"]]
+        return {
+            "message": "🔒 Scanning for PHI...",
+            "role": PAM_ROLE,
+            "has_phi": len(phi) > 0,
+            "entities": phi
+        }
+
+    def parse_log(self, log_text: str) -> Dict[str, Any]:
+        error = self._check_activation(log_text)
+        if error:
+            return {"message": error, "role": PAM_ROLE}
+
+        parsed = self.log_parser(log_text)
+        return {
+            "message": "🕵🏽‍♀️ Parsing log entry...",
+            "role": PAM_ROLE,
+            "log_entities": parsed
+        }
+
+    def summarize(self, raw_text: str) -> Dict[str, Any]:
+        error = self._check_activation(raw_text)
+        if error:
+            return {"message": error, "role": PAM_ROLE}
+
+        result = self.summarizer(raw_text[:1024], max_length=150, min_length=30, do_sample=False)
+        return {
+            "message": "📊 Summary generated:",
+            "role": PAM_ROLE,
+            "summary": result[0]["summary_text"]
+        }
+
+    def get_latest_logs(self) -> Dict[str, Any]:
+        if "latest_logs" not in self.LOGS:
+            return {"message": "No logs available. Check JSON file location and contents.", "role": PAM_ROLE}
+
+        full_logset = []
+        client_handoffs = []
+        for item in self.LOGS["latest_logs"]:
+            entry = item.get("entry", "")
+            time = item.get("timestamp", "Unknown time")
+            severity = classify_severity(entry)
+            formatted = f"[{time}] ({severity}) -> {entry}"
+            full_logset.append(formatted)
+
+            if "frontend" in entry.lower() or "provider unavailable" in entry.lower():
+                client_handoffs.append(formatted)
+
+        return {
+            "message": "📡 Infrastructure Log Review:",
+            "role": PAM_ROLE,
+            "logs": full_logset,
+            "handoff_to_frontend": client_handoffs
+        }
+
+    def check_compliance(self) -> Dict[str, Any]:
+        report = []
+        for item, status in self.COMPLIANCE.items():
+            emoji = "✅" if status else "❌"
+            report.append(f"{item.replace('_', ' ').title()}: {emoji}")
+        return {
+            "message": "🛡️ Compliance Status Overview:",
+            "role": PAM_ROLE,
+            "compliance_report": report
+        }
+
+    def process_input(self, user_input: str) -> Dict[str, Any]:
+        u_input = user_input.lower().strip()
+
+        if "check compliance" in u_input:
+            return self.check_compliance()
+        if "get logs" in u_input or "latest logs" in u_input:
+            return self.get_latest_logs()
+        if "detect phi in" in u_input:
+            text_to_scan = user_input[u_input.find("detect phi in") + len("detect phi in"):].strip()
+            return self.detect_phi(text_to_scan)
+        if "parse log" in u_input:
+            log_to_parse = user_input[u_input.find("parse log") + len("parse log"):].strip()
+            return self.parse_log(log_to_parse)
+        if "summarize" in u_input or "explain" in u_input:
+            return self.summarize(user_input)
+
+        return {
+            "response": f"Hello! I am PAM. I can process your request: '{user_input}'. Try commands like 'check compliance', 'get logs', 'detect phi in [text]', or 'parse log [log text]'.",
+            "role": PAM_ROLE
+        }

frontend_pam.py

@@ -0,0 +1,108 @@
+# filename: frontend_pam.py (UPDATED FOR HF INFERENCE API)
+
+import os
+import json
+import random
+import requests
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+# --- Constants for Data Paths ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+
+APPOINTMENTS_FILE = os.path.join(DATA_DIR, "appointments.json")
+RESOURCES_FILE = os.path.join(DATA_DIR, "resources.json")
+FOLLOW_UP_FILE = os.path.join(DATA_DIR, "follow_up.json")
+PERMISSIONS_FILE = os.path.join(DATA_DIR, "permissions.json")
+
+# --- HuggingFace Inference API Setup ---
+HF_API_TOKEN = os.getenv("HF_READ_TOKEN")
+HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+HF_ENDPOINTS = {
+    "intent": "https://api-inference.huggingface.co/models/typeform/distilbert-base-uncased-mnli",
+    "sentiment": "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english",
+    "summarizer": "https://api-inference.huggingface.co/models/google/flan-t5-large",
+    "chat": "https://api-inference.huggingface.co/models/tiiuae/falcon-7b-instruct"
+}
+
+# --- Load JSON Helper ---
+def load_json(filepath: str) -> Dict[str, Any]:
+    try:
+        with open(filepath, 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"CRITICAL: Data file not found at: {filepath}")
+        return {}
+    except json.JSONDecodeError as e:
+        print(f"CRITICAL: Failed to decode JSON from {filepath}: {e}")
+        return {}
+
+# --- Inference API Call Helper ---
+def hf_infer(task: str, payload: Any) -> Any:
+    url = HF_ENDPOINTS.get(task)
+    if not url:
+        return {"error": f"Invalid task: {task}"}
+    response = requests.post(url, headers=HF_HEADERS, json=payload)
+    if response.status_code != 200:
+        return {"error": f"HF API Error ({response.status_code})", "details": response.text}
+    return response.json()
+
+# --- Agent Initialization ---
+def load_frontend_agent() -> 'FrontendPAM':
+    print("Initializing Frontend PAM using HF Inference API...")
+    data = {
+        "APPOINTMENTS": load_json(APPOINTMENTS_FILE),
+        "RESOURCES": load_json(RESOURCES_FILE),
+        "FOLLOW_UP": load_json(FOLLOW_UP_FILE),
+        "PERMISSIONS": load_json(PERMISSIONS_FILE)
+    }
+    return FrontendPAM(data)
+
+# --- PAM Personality ---
+PAM_TONE = ("I am PAM — the cool older sister... [Full description abridged]")
+GREETINGS = ["babe", "love", "friend", "girl", "boo", "sweetheart"]
+
+# --- Agent Class ---
+class FrontendPAM:
+    def __init__(self, data: Dict[str, Dict]):
+        self.APPOINTMENTS = data.get("APPOINTMENTS", {})
+        self.PERMISSIONS = data.get("PERMISSIONS", {})
+        self.RESOURCES = data.get("RESOURCES", {})
+        self.FOLLOW_UP = data.get("FOLLOW_UP", {})
+        self.user_id = "user_001"
+
+    def respond(self, user_text: str, backend_brief: Optional[str] = None) -> Dict[str, Any]:
+        if not user_text.lower().startswith("hey pam"):
+            return {"reply": "Oops, you didn’t say 'Hey Pam'. I only respond to respectful greetings — you know how I am. 💅"}
+
+        text = user_text.replace("PAM", "you").replace("pam", "you")
+        detected_intent = hf_infer("intent", {"inputs": text})[0].get("label", "unknown")
+        sentiment_result = hf_infer("sentiment", {"inputs": text})[0]
+        backend_summary = backend_brief or "No backend input provided."
+        greeting = random.choice(GREETINGS)
+
+        for term, allowed in self.PERMISSIONS.items():
+            if term in text.lower() and not allowed:
+                return {"reply": f"That’s something I’m not allowed to help with directly, {greeting}. But I can connect you to a safe resource or provider if you’d like."}
+
+        if "appointment" in text.lower():
+            appt = self.APPOINTMENTS.get(self.user_id)
+            if appt:
+                return {"reply": f"Hey {greeting}, you've got a {appt['type']} scheduled..."}
+            else:
+                return {"reply": f"Hey {greeting}, I don’t have any appointments saved..."}
+
+        elif any(keyword in text.lower() for keyword in ["cramp", "discharge", "bleed", "smell", "spotting", "fatigue", "mood", "missed"]):
+            return {"reply": f"Okay {greeting}, I pulled a few resources I think will help..."}
+
+        else:
+            prompt = f"{PAM_TONE}\n... User said: {text}\nPAM:"
+            chat_output = hf_infer("chat", {"inputs": prompt})
+            reply = chat_output[0].get("generated_text", "Sorry love, I didn’t catch that. Try again?").split("PAM:")[-1].strip()
+            return {
+                "intent": detected_intent,
+                "sentiment": sentiment_result,
+                "summary": backend_summary,
+                "reply": reply
+            }

requirements.txt

@@ -0,0 +1,15 @@
+# filename: requirements.txt
+
+# Web Server / API Framework
+fastapi>=0.104.0
+uvicorn[standard]>=0.23.2
+gunicorn>=21.2.0
+pydantic>=2.4.2
+python-multipart>=0.0.6
+starlette>=0.35.1
+
+# AI/ML/Data Science Libraries (Used in backend_pam.py and frontend_pam.py)
+transformers>=4.34.0
+torch>=2.1.0
+boto3>=1.28.69
+# Add any other libraries required by your agents (e.g., specific AWS SDKs, scikit-learn, etc.)