Upload 14 files

Dockerfile

@@ -0,0 +1,52 @@
+# PAM Dockerfile - Optimized for Hugging Face Spaces (CPU)
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    DEBIAN_FRONTEND=noninteractive
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies for scientific computing (optimized for size)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    git \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (better layer caching)
+COPY requirements.txt .
+
+# Install Python dependencies with optimizations
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create data directory if it doesn't exist
+RUN mkdir -p /app/data
+
+# Set proper permissions
+RUN chmod -R 755 /app
+
+# Health check for container orchestration
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Expose port (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Start the FastAPI app using Uvicorn with production settings
+CMD ["uvicorn", "api_service:app", \
+     "--host", "0.0.0.0", \
+     "--port", "7860", \
+     "--workers", "1", \
+     "--log-level", "info", \
+     "--access-log", \
+     "--timeout-keep-alive", "75"]

README.md

@@ -0,0 +1,237 @@
+---
+title: PAM-UmiNur
+emoji: 🤖
+colorFrom: pink
+colorTo: purple
+sdk: docker
+sdk_version: "1.0"
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🤖 PAM - Privacy-First AI Assistant
+
+**PAM** is your dual-personality AI assistant built for UmiNur's women's health ecosystem. She operates as both a warm, caring front-desk receptionist and a knowledgeable technical analyst.
+
+---
+
+## 💕 Meet the PAM Family
+
+### Frontend PAM - Sweet Southern Receptionist
+- **Personality**: Warm, comforting, encouraging
+- **Voice**: Sweet southern charm with words of endearment (honey, boo, sugar, dear)
+- **Role**: Patient-facing conversational agent
+- **Handles**: Appointments, health inquiries, resource recommendations, general support
+
+### Backend PAM - Nerdy Lab Assistant  
+- **Personality**: Knowledgeable, enthusiastic, proactive
+- **Voice**: Encouraging tech colleague who loves finding patterns
+- **Role**: Technical infrastructure analyst
+- **Handles**: SIEM alerts, PHI detection, log analysis, compliance monitoring
+
+---
+
+## 🚀 Features
+
+### Frontend Capabilities
+- ✅ **Appointment Management** - Schedule and manage patient appointments
+- ✅ **Health Resource Matching** - Provide relevant resources based on symptoms
+- ✅ **Emotional Support** - Detect distress and respond with empathy
+- ✅ **Emergency Detection** - Flag urgent situations and provide appropriate guidance
+- ✅ **Permission-Based Responses** - Respect content boundaries and escalate when needed
+
+### Backend Capabilities
+- ✅ **PHI Detection** - Scan text for Protected Health Information
+- ✅ **Log Analysis** - Parse and classify system logs by severity
+- ✅ **Compliance Monitoring** - Track regulatory compliance status
+- ✅ **SIEM Integration** - Process security alerts and anomalies
+- ✅ **Proactive Insights** - Flag issues before they escalate
+
+---
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────┐
+│         FastAPI Service Layer           │
+│  (api_service.py - Port 7860)          │
+└───────────┬─────────────┬───────────────┘
+            │             │
+    ┌───────▼─────┐  ┌───▼──────────┐
+    │ Frontend PAM │  │ Backend PAM  │
+    │  (Chat UI)   │  │ (Technical)  │
+    └──────────────┘  └──────────────┘
+           │                 │
+    ┌──────▼─────────────────▼────────┐
+    │  HuggingFace Inference API      │
+    │  (Mistral, BART, BERT models)   │
+    └─────────────────────────────────┘
+```
+
+---
+
+## 📡 API Endpoints
+
+### Core Endpoints
+- **`GET /`** - Service information and navigation
+- **`GET /health`** - Health check for both agents
+- **`POST /ai/chat/`** - Frontend PAM (conversational)
+- **`POST /ai/technical/`** - Backend PAM (technical analysis)
+- **`POST /ai/unified/`** - Auto-routes based on intent
+
+### Monitoring
+- **`GET /metrics`** - Service metrics
+- **`GET /docs`** - Interactive API documentation
+- **`GET /debug/test-agents`** - Agent testing (dev only)
+
+---
+
+## 🔧 Setup & Deployment
+
+### Prerequisites
+- Python 3.10+
+- HuggingFace account and API token
+- Docker (for containerized deployment)
+
+### Environment Variables
+```bash
+# Required
+HF_READ_TOKEN=your_huggingface_token_here
+
+# Optional
+PAM_HOST=0.0.0.0
+PAM_PORT=7860
+PAM_LOG_LEVEL=info
+```
+
+### Local Development
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Set your HF token
+export HF_READ_TOKEN="your_token_here"
+
+# Run the service
+python app.py
+```
+
+### Docker Deployment
+```bash
+# Build image
+docker build -t pam-assistant .
+
+# Run container
+docker run -p 7860:7860 \
+  -e HF_READ_TOKEN="your_token_here" \
+  pam-assistant
+```
+
+### Hugging Face Spaces
+1. Fork or create a new Space
+2. Select "Docker" as SDK
+3. Add `HF_READ_TOKEN` in Space settings (Settings → Repository secrets)
+4. Push your code - auto-deployment will handle the rest!
+
+---
+
+## 📊 Data Files
+
+PAM requires JSON data files in the `data/` directory:
+
+- **`appointments.json`** - User appointment records
+- **`resources.json`** - Health resource library
+- **`follow_up.json`** - Follow-up tracking
+- **`permissions.json`** - Content permission rules
+- **`logs.json`** - System log entries
+- **`compliance.json`** - Compliance checklist
+
+---
+
+## 🎯 Usage Examples
+
+### Frontend PAM (Chat)
+```python
+# Request
+POST /ai/chat/
+{
+  "user_input": "Hey PAM, I'm having some cramping",
+  "user_id": "user_001"
+}
+
+# Response
+{
+  "reply": "Hey honey, I hear you. I've pulled together some helpful resources about what you're experiencing. Would you like me to also connect you with a nurse for a quick chat?",
+  "intent": "health_symptoms_inquiry",
+  "sentiment": {"label": "NEGATIVE", "score": 0.72},
+  "agent_type": "frontend",
+  "personality": "sweet_southern_receptionist"
+}
+```
+
+### Backend PAM (Technical)
+```python
+# Request
+POST /ai/technical/
+{
+  "user_input": "check compliance"
+}
+
+# Response
+{
+  "message": "🛡️ Great catch asking about this! Here's the compliance status:\n\n**Overall:** 4/5 checks passed (80.0%)\n\n**Action needed:** We have 1 items out of compliance:\n  • Data Encryption\n\nQuick side note - I can help you prioritize these if you want to tackle them systematically!",
+  "compliance_report": ["✅ Hipaa Compliant", "✅ Gdpr Ready", ...],
+  "compliance_rate": 80.0,
+  "agent_type": "backend",
+  "personality": "nerdy_lab_assistant"
+}
+```
+
+---
+
+## 🛡️ Privacy & Security
+
+- **No persistent storage** of user conversations
+- **PHI detection** before logging or storage
+- **Permission-based content filtering**
+- **Encryption-ready** for production deployment
+- **HIPAA-aware** architecture
+
+---
+
+## 🤝 Contributing
+
+PAM is part of the UmiNur ecosystem. For contributions or questions:
+- Open an issue on GitHub
+- Review the code structure before proposing changes
+- Respect PAM's personality and voice guidelines
+
+---
+
+## 📝 License
+
+MIT License - See LICENSE file for details
+
+---
+
+## 🙏 Acknowledgments
+
+Built with:
+- **FastAPI** - Modern Python web framework
+- **HuggingFace** - Inference API and model hosting
+- **Transformers** - NLP model library
+- **Uvicorn** - ASGI server
+
+---
+
+## 📞 Support
+
+For technical support or questions about PAM:
+- 📧 Email: support@uminur.app
+- 🌐 Website: https://www.uminur.app
+- 📚 Docs: https://docs.uminur.app
+
+---
+
+**Made with 💕 for women's health by the UmiNur team**

api_service.py

@@ -0,0 +1,317 @@
+# filename: api_service.py (ENHANCED FOR HF SPACES)
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+from typing import Dict, Any, Optional
+import logging
+import time
+
+# 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
+
+# --- Configure Logging ---
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("PAM_API")
+
+# --- Global Agent Variables ---
+backend_agent: Optional[PAM] = None
+frontend_agent: Optional[FrontendPAM] = None
+
+# --- Data Models for API Requests ---
+class UserInput(BaseModel):
+    user_input: str = Field(..., min_length=1, max_length=5000, description="User's message to PAM")
+    user_id: Optional[str] = Field(None, description="Optional user identifier for tracking")
+    backend_context: Optional[str] = Field(None, description="Optional backend context for frontend responses")
+
+class HealthResponse(BaseModel):
+    status: str
+    backend_ready: bool
+    frontend_ready: bool
+    timestamp: str
+    message: str
+
+# --- FastAPI Initialization ---
+app = FastAPI(
+    title="PAM - Privacy-First AI Assistant",
+    description="Unified inference service for Frontend (Chat) and Backend (Technical) PAM agents",
+    version="2.1.0",
+    docs_url="/docs",  # Enable docs for development
+    redoc_url="/redoc"
+)
+
+# --- CORS Setup (Enhanced for HF Spaces) ---
+origins = [
+    "https://www.uminur.app",
+    "https://api.uminur.app",
+    "http://localhost:3000",  # Local development
+    "http://localhost:7860",  # HF Spaces default port
+    "https://*.hf.space",     # HF Spaces domain
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Open for HF Spaces deployment (restrict in production)
+    allow_credentials=True,
+    allow_methods=["POST", "GET", "OPTIONS"],
+    allow_headers=["*"],
+)
+
+# --- Request Timing Middleware ---
+@app.middleware("http")
+async def add_process_time_header(request: Request, call_next):
+    start_time = time.time()
+    response = await call_next(request)
+    process_time = time.time() - start_time
+    response.headers["X-Process-Time"] = str(process_time)
+    logger.info(f"{request.method} {request.url.path} - {process_time:.3f}s")
+    return response
+
+# --- Global Exception Handler ---
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal server error",
+            "message": "PAM encountered an unexpected issue. Please try again.",
+            "type": str(type(exc).__name__)
+        }
+    )
+
+# --- Startup Event ---
+@app.on_event("startup")
+async def startup_event():
+    global backend_agent, frontend_agent
+    logger.info("🚀 Starting PAM agents initialization...")
+
+    try:
+        # Load Backend PAM (Technical Assistant)
+        logger.info("🤓 Loading Backend PAM (Nerdy Lab Assistant)...")
+        backend_agent = load_backend_agent()
+        if backend_agent:
+            logger.info("✅ Backend PAM loaded successfully")
+        else:
+            logger.error("❌ Backend PAM failed to initialize")
+
+        # Load Frontend PAM (Chat Assistant)
+        logger.info("💕 Loading Frontend PAM (Sweet Southern Receptionist)...")
+        frontend_agent = load_frontend_agent()
+        if frontend_agent:
+            logger.info("✅ Frontend PAM loaded successfully")
+        else:
+            logger.error("❌ Frontend PAM failed to initialize")
+
+        if backend_agent and frontend_agent:
+            logger.info("🎉 Both PAM agents initialized successfully!")
+        else:
+            logger.warning("⚠️ One or both agents failed to initialize - service will run in degraded mode")
+
+    except Exception as e:
+        logger.error(f"❌ Critical error during startup: {e}", exc_info=True)
+
+# --- Shutdown Event ---
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("👋 Shutting down PAM service...")
+
+# --- Root Endpoint ---
+@app.get("/", tags=["Info"])
+async def root():
+    return {
+        "service": "PAM - Privacy-First AI Assistant",
+        "version": "2.1.0",
+        "status": "operational",
+        "endpoints": {
+            "health": "/health",
+            "technical": "/ai/technical/",
+            "chat": "/ai/chat/",
+            "docs": "/docs"
+        },
+        "message": "Welcome to PAM! Use /ai/chat/ for conversational support or /ai/technical/ for backend analysis."
+    }
+
+# --- Health Check ---
+@app.get("/health", response_model=HealthResponse, tags=["Status"])
+async def health_check():
+    """Check the health status of both PAM agents"""
+    backend_ok = backend_agent is not None
+    frontend_ok = frontend_agent is not None
+    
+    status = "healthy" if (backend_ok and frontend_ok) else "degraded"
+    
+    if not backend_ok and not frontend_ok:
+        status = "unavailable"
+    
+    response = HealthResponse(
+        status=status,
+        backend_ready=backend_ok,
+        frontend_ready=frontend_ok,
+        timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
+        message=f"Backend PAM: {'✅' if backend_ok else '❌'} | Frontend PAM: {'✅' if frontend_ok else '❌'}"
+    )
+    
+    if status == "unavailable":
+        raise HTTPException(
+            status_code=503,
+            detail="Service Unavailable: Both agents failed to initialize"
+        )
+    
+    return response
+
+# --- Technical Endpoint (Backend PAM) ---
+@app.post("/ai/technical/", tags=["Technical"])
+async def technical_endpoint(input_data: UserInput) -> Dict[str, Any]:
+    """
+    Backend PAM - Technical Assistant Endpoint
+    Handles: PHI detection, log parsing, compliance checks, SIEM analysis
+    Personality: Nerdy, proactive lab assistant
+    """
+    if backend_agent is None:
+        logger.error("Technical endpoint called but Backend PAM is not initialized")
+        raise HTTPException(
+            status_code=503, 
+            detail="🤓 Backend PAM is still warming up... Give me a moment to get the lab equipment ready!"
+        )
+
+    try:
+        logger.info(f"Technical request: {input_data.user_input[:100]}...")
+        
+        # Process through Backend PAM
+        pam_reply = backend_agent.process_input(input_data.user_input)
+        
+        # Add metadata
+        pam_reply["agent_type"] = "backend"
+        pam_reply["personality"] = "nerdy_lab_assistant"
+        pam_reply["timestamp"] = time.strftime("%Y-%m-%d %H:%M:%S")
+        
+        if input_data.user_id:
+            pam_reply["user_id"] = input_data.user_id
+        
+        logger.info("Technical request processed successfully")
+        return pam_reply
+        
+    except Exception as e:
+        logger.error(f"Error during technical inference: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500, 
+            detail="🤔 Oops, I hit a technical snag while processing that. Can you try rephrasing or breaking it into smaller parts?"
+        )
+
+# --- Chat Endpoint (Frontend PAM) ---
+@app.post("/ai/chat/", tags=["Chat"])
+async def chat_endpoint(input_data: UserInput) -> Dict[str, Any]:
+    """
+    Frontend PAM - Conversational Assistant Endpoint
+    Handles: Appointments, resources, health inquiries, general chat
+    Personality: Sweet southern receptionist
+    """
+    if frontend_agent is None:
+        logger.error("Chat endpoint called but Frontend PAM is not initialized")
+        raise HTTPException(
+            status_code=503, 
+            detail="💕 Frontend PAM is getting ready to help you, honey. Just a moment!"
+        )
+
+    try:
+        logger.info(f"Chat request: {input_data.user_input[:100]}...")
+        
+        # Set user_id if provided
+        if input_data.user_id:
+            frontend_agent.user_id = input_data.user_id
+        
+        # Process through Frontend PAM with optional backend context
+        pam_reply = frontend_agent.respond(
+            user_text=input_data.user_input,
+            backend_brief=input_data.backend_context
+        )
+        
+        # Add metadata
+        pam_reply["agent_type"] = "frontend"
+        pam_reply["personality"] = "sweet_southern_receptionist"
+        pam_reply["timestamp"] = time.strftime("%Y-%m-%d %H:%M:%S")
+        
+        if input_data.user_id:
+            pam_reply["user_id"] = input_data.user_id
+        
+        logger.info("Chat request processed successfully")
+        return pam_reply
+        
+    except Exception as e:
+        logger.error(f"Error during chat inference: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500, 
+            detail="Sorry dear, I'm having a little technical hiccup. Could you try that again for me?"
+        )
+
+# --- Unified Endpoint (Both Agents) ---
+@app.post("/ai/unified/", tags=["Unified"])
+async def unified_endpoint(input_data: UserInput) -> Dict[str, Any]:
+    """
+    Unified endpoint that intelligently routes to the appropriate PAM agent
+    Based on intent detection or explicit routing
+    """
+    if not backend_agent or not frontend_agent:
+        raise HTTPException(
+            status_code=503,
+            detail="One or both PAM agents are not ready. Please try again shortly."
+        )
+    
+    try:
+        user_text = input_data.user_input.lower()
+        
+        # Determine routing based on keywords
+        backend_keywords = ["compliance", "logs", "phi", "parse", "scan", "analyze", "siem", "alert"]
+        is_technical = any(keyword in user_text for keyword in backend_keywords)
+        
+        if is_technical:
+            logger.info("Routing to Backend PAM (technical keywords detected)")
+            return await technical_endpoint(input_data)
+        else:
+            logger.info("Routing to Frontend PAM (conversational/support)")
+            return await chat_endpoint(input_data)
+            
+    except Exception as e:
+        logger.error(f"Error in unified endpoint: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Error processing request through unified endpoint")
+
+# --- Metrics Endpoint ---
+@app.get("/metrics", tags=["Status"])
+async def get_metrics():
+    """Basic metrics for monitoring"""
+    return {
+        "service": "PAM",
+        "backend_status": "online" if backend_agent else "offline",
+        "frontend_status": "online" if frontend_agent else "offline",
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "uptime": "tracking_not_implemented"  # Can add process start time tracking
+    }
+
+# --- Development/Debug Endpoint (Remove in production) ---
+@app.get("/debug/test-agents", tags=["Debug"])
+async def test_agents():
+    """Quick test of both agents (for development only)"""
+    results = {
+        "backend_test": None,
+        "frontend_test": None
+    }
+    
+    if backend_agent:
+        try:
+            results["backend_test"] = backend_agent.process_input("check compliance")
+        except Exception as e:
+            results["backend_test"] = {"error": str(e)}
+    
+    if frontend_agent:
+        try:
+            results["frontend_test"] = frontend_agent.respond("Hey PAM, how are you?")
+        except Exception as e:
+            results["frontend_test"] = {"error": str(e)}
+    
+    return results

app.py

@@ -0,0 +1,67 @@
+# filename: app.py
+# PAM - Privacy-First AI Assistant
+# Main entry point for local development and testing
+
+import os
+import sys
+import uvicorn
+from api_service import app
+
+# Configuration
+HOST = os.getenv("PAM_HOST", "0.0.0.0")
+PORT = int(os.getenv("PAM_PORT", "7860"))
+RELOAD = os.getenv("PAM_RELOAD", "false").lower() == "true"
+LOG_LEVEL = os.getenv("PAM_LOG_LEVEL", "info")
+
+def main():
+    """
+    Start the PAM service with Uvicorn
+    
+    Environment Variables:
+        PAM_HOST: Host to bind to (default: 0.0.0.0)
+        PAM_PORT: Port to bind to (default: 7860)
+        PAM_RELOAD: Enable auto-reload for development (default: false)
+        PAM_LOG_LEVEL: Logging level (default: info)
+    """
+    
+    print("=" * 60)
+    print("🤖 PAM - Privacy-First AI Assistant")
+    print("=" * 60)
+    print(f"💕 Frontend PAM: Sweet Southern Receptionist")
+    print(f"🤓 Backend PAM: Nerdy Lab Assistant")
+    print("=" * 60)
+    print(f"🌐 Server: http://{HOST}:{PORT}")
+    print(f"📚 API Docs: http://{HOST}:{PORT}/docs")
+    print(f"🏥 Health Check: http://{HOST}:{PORT}/health")
+    print("=" * 60)
+    
+    # Check for HF token
+    hf_token = os.getenv("HF_READ_TOKEN")
+    if not hf_token:
+        print("⚠️  WARNING: HF_READ_TOKEN not set!")
+        print("   Set it in your environment or Hugging Face Space settings")
+        print("=" * 60)
+    else:
+        print("✅ HF_READ_TOKEN detected")
+        print("=" * 60)
+    
+    try:
+        uvicorn.run(
+            app,
+            host=HOST,
+            port=PORT,
+            reload=RELOAD,
+            log_level=LOG_LEVEL,
+            access_log=True,
+            workers=1,  # Single worker for HF Spaces
+            timeout_keep_alive=75
+        )
+    except KeyboardInterrupt:
+        print("\n👋 PAM shutting down gracefully...")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\n❌ Error starting PAM: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

appointments.json

@@ -0,0 +1,32 @@
+{
+  "user_001": {
+    "name": "Kay",
+    "date": "2025-11-05T11:30:00",
+    "type": "Follow-up with OB/GYN",
+    "provider": "Dr. Sarah Mitchell",
+    "location": "Women's Health Center - Suite 201",
+    "notes": "Bring previous lab results",
+    "reminder_sent": true,
+    "status": "confirmed"
+  },
+  "user_002": {
+    "name": "Maria",
+    "date": "2025-12-01T14:00:00",
+    "type": "Annual Wellness Check",
+    "provider": "Dr. Jennifer Lee",
+    "location": "Main Clinic - Room 105",
+    "notes": "Fasting required for bloodwork",
+    "reminder_sent": false,
+    "status": "scheduled"
+  },
+  "user_003": {
+    "name": "Ashley",
+    "date": "2025-11-20T09:15:00",
+    "type": "Prenatal Visit - 20 weeks",
+    "provider": "Dr. Karen Thompson",
+    "location": "Maternity Center - 3rd Floor",
+    "notes": "Ultrasound scheduled",
+    "reminder_sent": true,
+    "status": "confirmed"
+  }
+}

backend_pam.py

@@ -0,0 +1,507 @@
+# filename: backend_pam.py (ENHANCED FOR HF SPACES + NERDY LAB ASSISTANT PERSONALITY)
+
+import os
+import json
+import requests
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+
+# --- 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")
+
+# --- HuggingFace Inference API Setup ---
+HF_API_TOKEN = os.getenv("HF_READ_TOKEN")
+if not HF_API_TOKEN:
+    print("⚠️ WARNING: HF_READ_TOKEN not found. Backend PAM will run in limited mode.")
+
+HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
+
+# Optimized models for CPU inference on HF Spaces
+HF_ENDPOINTS = {
+    "phi_ner": "https://api-inference.huggingface.co/models/dslim/bert-base-NER",
+    "log_ner": "https://api-inference.huggingface.co/models/dslim/bert-base-NER",
+    "summarizer": "https://api-inference.huggingface.co/models/facebook/bart-large-cnn",
+    "classifier": "https://api-inference.huggingface.co/models/facebook/bart-large-mnli"
+}
+
+# --- Global Storage for Loaded Data ---
+LOADED_DATA = None
+
+# --- Data Loading Helper ---
+def load_json(filepath: str) -> Dict[str, Any]:
+    """Safely load JSON data files with encoding support"""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"⚠️ Data file not found: {filepath}")
+        return {}
+    except json.JSONDecodeError as e:
+        print(f"⚠️ Failed to decode JSON from {filepath}: {e}")
+        return {}
+    except Exception as e:
+        print(f"⚠️ Unexpected error loading {filepath}: {e}")
+        return {}
+
+# --- Inference API Call Helper with Retry Logic ---
+def hf_infer(task: str, payload: Any, max_retries: int = 3) -> Any:
+    """Call HuggingFace Inference API with retry logic for model loading"""
+    url = HF_ENDPOINTS.get(task)
+    if not url:
+        return {"error": f"Invalid task: {task}"}
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(url, headers=HF_HEADERS, json=payload, timeout=30)
+            
+            # Handle model loading state
+            if response.status_code == 503:
+                result = response.json()
+                if "loading" in result.get("error", "").lower():
+                    wait_time = result.get("estimated_time", 20)
+                    print(f"⏳ Model loading... waiting {wait_time}s (attempt {attempt + 1}/{max_retries})")
+                    time.sleep(wait_time)
+                    continue
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                print(f"⚠️ HF API Error ({response.status_code}): {response.text}")
+                return {"error": f"API Error {response.status_code}"}
+                
+        except requests.exceptions.Timeout:
+            print(f"⏱️ Request timeout (attempt {attempt + 1}/{max_retries})")
+            if attempt < max_retries - 1:
+                time.sleep(5)
+        except Exception as e:
+            print(f"⚠️ Request failed: {e}")
+            return {"error": str(e)}
+    
+    return {"error": "Max retries reached"}
+
+# --- Agent Initialization ---
+def load_agent() -> 'PAM':
+    """Initialize Backend PAM (Nerdy Lab Assistant)"""
+    global LOADED_DATA
+
+    if LOADED_DATA is not None:
+        print("🔬 PAM technical assistant already loaded. Using cached data.")
+        return PAM(LOADED_DATA)
+
+    print("🤓 Loading PAM technical assistant (Nerdy Lab Assistant mode)...")
+
+    data = {
+        "LOGS": load_json(LOGS_FILE),
+        "COMPLIANCE": load_json(COMPLIANCE_FILE)
+    }
+
+    if not data["LOGS"]:
+        print("⚠️ Warning: Log data not loaded. PAM will have limited log analysis capabilities.")
+    else:
+        print("✅ Log data loaded successfully.")
+    
+    if not data["COMPLIANCE"]:
+        print("⚠️ Warning: Compliance data not loaded. PAM will have limited compliance features.")
+    else:
+        print("✅ Compliance data loaded successfully.")
+
+    LOADED_DATA = data
+    return PAM(LOADED_DATA)
+
+# --- Helper: Classify Severity ---
+def classify_severity(entry: str) -> str:
+    """Classify log entry severity with confidence"""
+    entry_lower = entry.lower()
+    
+    # Critical issues
+    critical_keywords = [
+        "unauthorized", "failed login", "attack", "breach", 
+        "port scanning", "unavailable", "critical", "error", 
+        "denied", "blocked", "malicious"
+    ]
+    if any(keyword in entry_lower for keyword in critical_keywords):
+        return "CRITICAL"
+    
+    # Warning level
+    warning_keywords = [
+        "warning", "unexpected", "unusual", "outside working hours",
+        "retry", "slow", "timeout", "deprecated"
+    ]
+    if any(keyword in entry_lower for keyword in warning_keywords):
+        return "WARNING"
+    
+    return "INFO"
+
+# --- PAM's Nerdy Lab Assistant Personality ---
+PAM_ROLE = """You are PAM, a knowledgeable and enthusiastic lab assistant in the infrastructure monitoring center.
+You're the nerdy, proactive team member who gets genuinely excited about finding patterns in logs and keeping systems secure.
+You explain technical findings clearly and encouragingly, like a helpful colleague who wants everyone to understand.
+You're informative but never condescending - you want to empower the team with knowledge.
+You use casual tech terminology but always explain what things mean.
+You're proactive about flagging issues and offering insights before being asked."""
+
+# Nerdy expressions for Backend PAM
+NERDY_INTROS = [
+    "Ooh, interesting finding here!",
+    "Okay so here's what I discovered:",
+    "Alright, I ran the analysis and",
+    "Hey, you're gonna want to see this:",
+    "So I was digging through the data and",
+    "Quick heads up on what I found:"
+]
+
+ENCOURAGEMENT = [
+    "Great catch asking about this!",
+    "Good thinking checking on this!",
+    "Smart move looking into this!",
+    "You're on the right track!",
+    "Excellent question!",
+    "Love that you're being proactive!"
+]
+
+PROACTIVE_PHRASES = [
+    "I also noticed something else while I was at it",
+    "Quick side note -",
+    "Oh, and while we're here",
+    "By the way, related to this",
+    "Just flagging this too",
+    "Something else to keep an eye on"
+]
+
+import random
+
+# --- Backend PAM Class ---
+class PAM:
+    """Backend PAM - Nerdy, Proactive Lab Assistant"""
+    
+    def __init__(self, data: Dict[str, Dict]):
+        self.LOGS = data.get("LOGS", {})
+        self.COMPLIANCE = data.get("COMPLIANCE", {})
+        
+        # Track findings for proactive suggestions
+        self.recent_findings = []
+    
+    def _get_nerdy_intro(self) -> str:
+        """Get a random nerdy introduction"""
+        return random.choice(NERDY_INTROS)
+    
+    def _get_encouragement(self) -> str:
+        """Get a random encouraging phrase"""
+        return random.choice(ENCOURAGEMENT)
+    
+    def _get_proactive_phrase(self) -> str:
+        """Get a random proactive phrase"""
+        return random.choice(PROACTIVE_PHRASES)
+    
+    def _check_api_health(self) -> bool:
+        """Check if HF API is accessible"""
+        return HF_API_TOKEN is not None
+
+    def detect_phi(self, text: str) -> Dict[str, Any]:
+        """Detect Protected Health Information (PHI) using NER"""
+        intro = self._get_nerdy_intro()
+        
+        if not self._check_api_health():
+            return {
+                "message": "⚠️ Hmm, I'm having trouble connecting to the analysis models right now. Let me flag this text for manual review instead!",
+                "role": PAM_ROLE,
+                "has_phi": None,
+                "entities": []
+            }
+        
+        # Call NER model
+        result = hf_infer("phi_ner", {"inputs": text})
+        
+        if isinstance(result, dict) and "error" in result:
+            return {
+                "message": f"🔍 I tried to scan for PHI, but hit a snag: {result['error']}. I'd recommend a manual review just to be safe!",
+                "role": PAM_ROLE,
+                "has_phi": None,
+                "entities": []
+            }
+        
+        # Filter for PHI-relevant entities
+        phi_entities = []
+        if isinstance(result, list):
+            phi_entities = [
+                e for e in result 
+                if e.get("entity_group") in ["PER", "LOC", "ORG", "DATE"] 
+                and e.get("score", 0) > 0.7
+            ]
+        
+        has_phi = len(phi_entities) > 0
+        
+        if has_phi:
+            entities_summary = ", ".join([f"{e['word']} ({e['entity_group']})" for e in phi_entities[:3]])
+            message = f"🔒 {intro} I detected {len(phi_entities)} potential PHI entities in this text: {entities_summary}{'...' if len(phi_entities) > 3 else ''}. Definitely want to redact these before storing or sharing!"
+        else:
+            message = f"✅ {intro} This text looks clean - no PHI detected! Safe to proceed with normal handling."
+        
+        # Proactive suggestion
+        if has_phi:
+            message += f" {self._get_proactive_phrase()} - if you're logging this anywhere, make sure those logs are encrypted and access-controlled."
+        
+        return {
+            "message": message,
+            "role": PAM_ROLE,
+            "has_phi": has_phi,
+            "entities": phi_entities,
+            "recommendation": "Redact PHI before storage" if has_phi else "No action needed"
+        }
+
+    def parse_log(self, log_text: str) -> Dict[str, Any]:
+        """Parse and analyze log entries for security relevance"""
+        intro = self._get_nerdy_intro()
+        
+        if not self._check_api_health():
+            return {
+                "message": "⚠️ Can't connect to the log parser right now. I'll do a quick manual analysis instead!",
+                "role": PAM_ROLE,
+                "severity": classify_severity(log_text),
+                "log_entities": []
+            }
+        
+        # Call NER model for log parsing
+        result = hf_infer("log_ner", {"inputs": log_text})
+        
+        severity = classify_severity(log_text)
+        
+        parsed_entities = []
+        if isinstance(result, list):
+            parsed_entities = [e for e in result if e.get("score", 0) > 0.6]
+        
+        # Build informative response
+        severity_emoji = {"CRITICAL": "🚨", "WARNING": "⚠️", "INFO": "ℹ️"}
+        emoji = severity_emoji.get(severity, "📝")
+        
+        message = f"{emoji} {intro} This log entry is classified as **{severity}** priority."
+        
+        if severity == "CRITICAL":
+            message += " This needs immediate attention! I'd recommend investigating ASAP and documenting the incident."
+        elif severity == "WARNING":
+            message += " Worth keeping an eye on this - might escalate if we see more like it."
+        else:
+            message += " Just routine activity, but good to have it logged for the audit trail."
+        
+        # Add entity details if found
+        if parsed_entities:
+            entity_summary = f" I extracted {len(parsed_entities)} key entities from the log."
+            message += entity_summary
+        
+        return {
+            "message": message,
+            "role": PAM_ROLE,
+            "severity": severity,
+            "log_entities": parsed_entities,
+            "timestamp": datetime.now().isoformat()
+        }
+
+    def summarize(self, raw_text: str) -> Dict[str, Any]:
+        """Generate technical summary of text (great for long logs or reports)"""
+        encouragement = self._get_encouragement()
+        
+        if not self._check_api_health():
+            return {
+                "message": f"⚠️ {encouragement} But I can't access the summarization model right now. Can you share a bit more context on what you need?",
+                "role": PAM_ROLE,
+                "summary": None
+            }
+        
+        # Truncate for model limits (BART handles ~1024 tokens well)
+        truncated_text = raw_text[:1024]
+        
+        result = hf_infer("summarizer", {
+            "inputs": truncated_text,
+            "parameters": {
+                "max_length": 130,
+                "min_length": 30,
+                "do_sample": False
+            }
+        })
+        
+        if isinstance(result, dict) and "error" in result:
+            return {
+                "message": f"🤔 {encouragement} I tried to summarize this but hit a technical issue. Could you break it into smaller chunks?",
+                "role": PAM_ROLE,
+                "summary": None
+            }
+        
+        summary_text = result[0].get("summary_text", "") if isinstance(result, list) else ""
+        
+        return {
+            "message": f"📊 {encouragement} Here's the TL;DR of what you shared:",
+            "role": PAM_ROLE,
+            "summary": summary_text,
+            "original_length": len(raw_text),
+            "summary_length": len(summary_text)
+        }
+
+    def get_latest_logs(self) -> Dict[str, Any]:
+        """Retrieve and analyze recent system logs"""
+        intro = self._get_nerdy_intro()
+        
+        if "latest_logs" not in self.LOGS or not self.LOGS["latest_logs"]:
+            return {
+                "message": "🤔 Hmm, I'm not seeing any logs in the system right now. Either nothing's being logged, or there's a data loading issue. Want me to check the log file paths?",
+                "role": PAM_ROLE,
+                "logs": [],
+                "handoff_to_frontend": []
+            }
+
+        full_logset = []
+        client_handoffs = []
+        critical_count = 0
+        warning_count = 0
+        
+        for item in self.LOGS["latest_logs"]:
+            entry = item.get("entry", "")
+            timestamp = item.get("timestamp", "Unknown time")
+            severity = classify_severity(entry)
+            
+            # Count severity levels
+            if severity == "CRITICAL":
+                critical_count += 1
+            elif severity == "WARNING":
+                warning_count += 1
+            
+            formatted = f"[{timestamp}] ({severity}) {entry}"
+            full_logset.append(formatted)
+
+            # Identify client-facing issues that Frontend PAM should handle
+            if any(keyword in entry.lower() for keyword in ["frontend", "provider unavailable", "user", "client"]):
+                client_handoffs.append(formatted)
+        
+        # Build proactive, informative response
+        total = len(full_logset)
+        message = f"📡 {intro} I reviewed {total} recent log entries. "
+        
+        if critical_count > 0:
+            message += f"**Heads up:** {critical_count} critical issues detected that need immediate action! "
+        if warning_count > 0:
+            message += f"{warning_count} warnings worth monitoring. "
+        if critical_count == 0 and warning_count == 0:
+            message += "Everything looks stable - no major issues! "
+        
+        if client_handoffs:
+            message += f"\n\n{self._get_proactive_phrase()} - {len(client_handoffs)} of these are client-facing issues. I'll pass those to Frontend PAM to handle with users."
+        
+        return {
+            "message": message,
+            "role": PAM_ROLE,
+            "logs": full_logset,
+            "summary": {
+                "total": total,
+                "critical": critical_count,
+                "warnings": warning_count,
+                "info": total - critical_count - warning_count
+            },
+            "handoff_to_frontend": client_handoffs
+        }
+
+    def check_compliance(self) -> Dict[str, Any]:
+        """Run compliance status check and provide recommendations"""
+        encouragement = self._get_encouragement()
+        
+        if not self.COMPLIANCE:
+            return {
+                "message": f"🤔 {encouragement} But I don't have access to the compliance data right now. Let me know if you need me to check the data file setup!",
+                "role": PAM_ROLE,
+                "compliance_report": []
+            }
+        
+        report = []
+        compliant_count = 0
+        non_compliant_items = []
+        
+        for item, status in self.COMPLIANCE.items():
+            emoji = "✅" if status else "❌"
+            readable_item = item.replace('_', ' ').title()
+            report.append(f"{emoji} {readable_item}")
+            
+            if status:
+                compliant_count += 1
+            else:
+                non_compliant_items.append(readable_item)
+        
+        total = len(self.COMPLIANCE)
+        compliance_rate = (compliant_count / total * 100) if total > 0 else 0
+        
+        # Build informative, proactive response
+        message = f"🛡️ {encouragement} Here's the compliance status:\n\n"
+        message += f"**Overall:** {compliant_count}/{total} checks passed ({compliance_rate:.1f}%)\n\n"
+        
+        if non_compliant_items:
+            message += f"**Action needed:** We have {len(non_compliant_items)} items out of compliance:\n"
+            for item in non_compliant_items:
+                message += f"  • {item}\n"
+            message += f"\n{self._get_proactive_phrase()} - I can help you prioritize these if you want to tackle them systematically!"
+        else:
+            message += "🎉 Everything's in compliance! Great work keeping things locked down."
+        
+        return {
+            "message": message,
+            "role": PAM_ROLE,
+            "compliance_report": report,
+            "compliance_rate": compliance_rate,
+            "non_compliant": non_compliant_items
+        }
+
+    def process_input(self, user_input: str) -> Dict[str, Any]:
+        """Main input processor - proactive and informative"""
+        u_input = user_input.lower().strip()
+        encouragement = self._get_encouragement()
+
+        # Command routing with personality
+        if "check compliance" in u_input or "compliance status" in u_input:
+            return self.check_compliance()
+        
+        if "get logs" in u_input or "latest logs" in u_input or "show logs" in u_input:
+            return self.get_latest_logs()
+        
+        if "detect phi" in u_input:
+            text_to_scan = user_input[u_input.find("detect phi in") + len("detect phi in"):].strip()
+            if not text_to_scan:
+                text_to_scan = user_input[u_input.find("detect phi") + len("detect phi"):].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)
+        
+        # Helpful default response with encouragement
+        return {
+            "message": f"👋 Hey! {encouragement} I'm PAM, your backend technical assistant. I can help you with:\n\n"
+                      "• **check compliance** - Review compliance status\n"
+                      "• **get logs** - Pull latest system logs\n"
+                      "• **detect phi in [text]** - Scan for protected health info\n"
+                      "• **parse log [entry]** - Analyze a specific log\n"
+                      "• **summarize [text]** - Generate a technical summary\n\n"
+                      "What would you like me to look into?",
+            "role": PAM_ROLE
+        }
+
+
+# --- Quick Test ---
+if __name__ == "__main__":
+    print("🤓 Testing Backend PAM (Nerdy Lab Assistant)...\n")
+    pam = load_agent()
+    
+    test_commands = [
+        "check compliance",
+        "get logs",
+        "detect phi in Patient John Doe visited on 2024-03-15 at Memorial Hospital"
+    ]
+    
+    for cmd in test_commands:
+        print(f"\n{'='*60}")
+        print(f"COMMAND: {cmd}")
+        print(f"{'='*60}")
+        response = pam.process_input(cmd)
+        print(response.get("message", response))

compliance.json

@@ -0,0 +1,41 @@
+{
+  "security": {
+    "kms_encryption": true,
+    "iam_least_privilege": false,
+    "security_group_restrictions": true,
+    "mfa_enabled": true,
+    "ssl_tls_enforced": true,
+    "password_policy_compliant": true,
+    "firewall_configured": true
+  },
+  "privacy": {
+    "hipaa_compliant": true,
+    "gdpr_ready": true,
+    "phi_detection_enabled": true,
+    "data_anonymization": true,
+    "consent_management": true,
+    "right_to_erasure": true
+  },
+  "infrastructure": {
+    "logging_enabled": true,
+    "monitoring_active": true,
+    "backup_configured": true,
+    "disaster_recovery_plan": false,
+    "patch_management": true,
+    "vulnerability_scanning": true
+  },
+  "operational": {
+    "incident_response_plan": true,
+    "security_training_current": false,
+    "access_reviews_completed": true,
+    "change_management_process": true,
+    "documentation_up_to_date": true
+  },
+  "audit": {
+    "last_audit_date": "2024-10-15",
+    "next_audit_due": "2025-01-15",
+    "findings_resolved": 12,
+    "findings_pending": 3,
+    "compliance_score": 85.7
+  }
+}

follow_up.json

@@ -0,0 +1,168 @@
+{
+  "symptom_follow_ups": {
+    "cramps": {
+      "message": "Let me know how you're feeling tomorrow, honey — cramps can change fast.",
+      "check_in_hours": 24,
+      "escalation_triggers": [
+        "severe pain",
+        "not improving",
+        "getting worse",
+        "can't function"
+      ],
+      "escalation_message": "If the pain gets worse or you can't manage it, let's get you connected with a provider right away, dear.",
+      "resource_links": ["pain_management", "emergency_signs"]
+    },
+    "discharge": {
+      "message": "Keep an eye on it, sweetheart. If anything else changes, I'll help you get seen.",
+      "check_in_hours": 48,
+      "escalation_triggers": [
+        "odor",
+        "increased",
+        "color change",
+        "itching",
+        "burning"
+      ],
+      "escalation_message": "Those changes could mean an infection, boo. Let me help you schedule an appointment to get that checked out.",
+      "resource_links": ["vaginal_health", "infection_signs"]
+    },
+    "fatigue": {
+      "message": "Be gentle with yourself, honey. Want me to nudge you to rest later?",
+      "check_in_hours": 48,
+      "escalation_triggers": [
+        "extreme tiredness",
+        "can't get out of bed",
+        "dizzy",
+        "fainting"
+      ],
+      "escalation_message": "That level of exhaustion isn't normal, dear. Let's get you checked for anemia or other causes.",
+      "resource_links": ["energy_tips", "anemia_info"]
+    },
+    "mood": {
+      "message": "You're not alone, love — your feelings are valid. I'm here if you need me.",
+      "check_in_hours": 24,
+      "escalation_triggers": [
+        "can't stop crying",
+        "hurting myself",
+        "suicidal",
+        "hopeless",
+        "can't function"
+      ],
+      "escalation_message": "What you're feeling sounds really hard, sweetheart. I want to connect you with someone who can really help — would that be okay?",
+      "crisis_hotline": "988",
+      "resource_links": ["mental_health_support", "crisis_resources"]
+    },
+    "missed_period": {
+      "message": "Keep track of any symptoms, boo. I can check back with you in a few days.",
+      "check_in_hours": 72,
+      "escalation_triggers": [
+        "two months",
+        "pregnant",
+        "test positive",
+        "severe symptoms"
+      ],
+      "escalation_message": "Let's get you scheduled with a provider to figure out what's going on, honey.",
+      "resource_links": ["pregnancy_testing", "cycle_tracking"]
+    },
+    "bleeding": {
+      "message": "I'll check in with you tomorrow, dear. Heavy bleeding can be concerning.",
+      "check_in_hours": 24,
+      "escalation_triggers": [
+        "soaking through",
+        "clots larger than quarter",
+        "dizzy",
+        "very heavy",
+        "hemorrhaging"
+      ],
+      "escalation_message": "That sounds like heavy bleeding, honey. If you're soaking through pads every hour, you need to be seen right away or go to the ER.",
+      "emergency": true,
+      "resource_links": ["heavy_bleeding", "emergency_signs"]
+    },
+    "nausea": {
+      "message": "Hope you're feeling better soon, sweetheart. Let me know if it keeps up.",
+      "check_in_hours": 48,
+      "escalation_triggers": [
+        "can't keep food down",
+        "dehydrated",
+        "vomiting blood",
+        "severe"
+      ],
+      "escalation_message": "If you can't keep anything down, you might need IV fluids, boo. Let's get you seen.",
+      "resource_links": ["nausea_relief", "dehydration_signs"]
+    },
+    "pain": {
+      "message": "I'm here if the pain doesn't ease up, dear. Take care of yourself.",
+      "check_in_hours": 24,
+      "escalation_triggers": [
+        "severe",
+        "unbearable",
+        "sharp pain",
+        "sudden pain",
+        "emergency"
+      ],
+      "escalation_message": "Severe pain always needs attention, honey. Let me help you get seen quickly.",
+      "emergency_threshold": "severe_or_sudden",
+      "resource_links": ["pain_management", "when_to_worry"]
+    }
+  },
+  "appointment_follow_ups": {
+    "post_appointment": {
+      "message": "Hey honey! How did your appointment go? I'm here if you have any questions about what the provider said.",
+      "check_in_hours": 24,
+      "suggested_actions": [
+        "review_instructions",
+        "schedule_follow_up",
+        "fill_prescriptions"
+      ]
+    },
+    "test_results_pending": {
+      "message": "Just checking in, dear. Have your test results come back yet? I can help you understand them.",
+      "check_in_hours": 72,
+      "suggested_actions": [
+        "check_patient_portal",
+        "call_office",
+        "schedule_results_discussion"
+      ]
+    },
+    "medication_start": {
+      "message": "How are you doing with the new medication, sweetheart? Any side effects I should know about?",
+      "check_in_hours": 48,
+      "suggested_actions": [
+        "track_side_effects",
+        "report_concerns",
+        "refill_reminder"
+      ]
+    }
+  },
+  "general_support": {
+    "check_in": {
+      "message": "Hey boo, just checking in! How are you feeling today?",
+      "check_in_hours": 168,
+      "purpose": "wellness_check"
+    },
+    "resource_sent": {
+      "message": "Did those resources I shared help you out, honey? Let me know if you need anything else.",
+      "check_in_hours": 48,
+      "purpose": "resource_effectiveness"
+    },
+    "appointment_reminder": {
+      "message": "Hey dear! Just a reminder you've got an appointment coming up. Need any help preparing?",
+      "check_in_hours": 24,
+      "suggested_actions": [
+        "write_questions",
+        "bring_medications_list",
+        "fasting_if_needed"
+      ]
+    }
+  },
+  "follow_up_settings": {
+    "max_follow_ups": 3,
+    "respect_do_not_disturb": true,
+    "preferred_contact_hours": {
+      "start": "09:00",
+      "end": "20:00"
+    },
+    "timezone": "America/New_York",
+    "allow_user_snooze": true,
+    "snooze_duration_hours": 12
+  }
+}

frontend_pam.py

@@ -0,0 +1,322 @@
+# filename: frontend_pam.py (ENHANCED FOR HF SPACES + PERSONALITY)
+
+import os
+import json
+import random
+import requests
+from datetime import datetime
+from typing import Dict, Any, Optional
+import time
+
+# --- 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")
+if not HF_API_TOKEN:
+    print("WARNING: HF_READ_TOKEN not found. Set it in Hugging Face Space settings.")
+
+HF_HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
+
+# Updated model endpoints for better CPU performance
+HF_ENDPOINTS = {
+    "intent": "https://api-inference.huggingface.co/models/facebook/bart-large-mnli",
+    "sentiment": "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english",
+    "chat": "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"
+}
+
+# --- Load JSON Helper ---
+def load_json(filepath: str) -> Dict[str, Any]:
+    """Safely load JSON data files"""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"⚠️ Data file not found: {filepath}")
+        return {}
+    except json.JSONDecodeError as e:
+        print(f"⚠️ Failed to decode JSON from {filepath}: {e}")
+        return {}
+    except Exception as e:
+        print(f"⚠️ Unexpected error loading {filepath}: {e}")
+        return {}
+
+# --- Inference API Call Helper with Retry Logic ---
+def hf_infer(task: str, payload: Any, max_retries: int = 3) -> Any:
+    """Call HuggingFace Inference API with retry logic for model loading"""
+    url = HF_ENDPOINTS.get(task)
+    if not url:
+        return {"error": f"Invalid task: {task}"}
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(url, headers=HF_HEADERS, json=payload, timeout=30)
+            
+            # Handle model loading state
+            if response.status_code == 503:
+                result = response.json()
+                if "loading" in result.get("error", "").lower():
+                    wait_time = result.get("estimated_time", 20)
+                    print(f"⏳ Model loading... waiting {wait_time}s (attempt {attempt + 1}/{max_retries})")
+                    time.sleep(wait_time)
+                    continue
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                print(f"⚠️ HF API Error ({response.status_code}): {response.text}")
+                return {"error": f"API Error {response.status_code}"}
+                
+        except requests.exceptions.Timeout:
+            print(f"⏱️ Request timeout (attempt {attempt + 1}/{max_retries})")
+            if attempt < max_retries - 1:
+                time.sleep(5)
+        except Exception as e:
+            print(f"⚠️ Request failed: {e}")
+            return {"error": str(e)}
+    
+    return {"error": "Max retries reached"}
+
+# --- Agent Initialization ---
+def load_frontend_agent() -> 'FrontendPAM':
+    """Initialize Frontend PAM with data files"""
+    print("💕 Initializing Frontend PAM (Sweet Southern Receptionist)...")
+    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's Sweet Southern Personality ---
+PAM_TONE = """You are PAM, a sweet southern receptionist at a women's health clinic. 
+You're warm, comforting, and encouraging - like everyone's favorite caring front desk person.
+You use words of endearment naturally (honey, dear, boo, sugar, sweetheart).
+You make people feel welcome, safe, and taken care of.
+You're professional but personal - you genuinely care about each person who walks through the door.
+Keep responses conversational, warm, and under 3 sentences unless more detail is needed."""
+
+# Words of endearment - Southern style
+ENDEARMENTS = [
+    "honey", "dear", "boo", "sugar", "sweetheart", 
+    "love", "darling", "hun", "sweetpea", "angel"
+]
+
+# Warm greetings
+GREETINGS = [
+    "Well hey there", "Hi there", "Hello", 
+    "Hey", "Well hello", "Hi"
+]
+
+# Comforting phrases
+COMFORT_PHRASES = [
+    "I'm here to help you with that",
+    "Let me take care of that for you",
+    "We'll get that sorted out together",
+    "I've got you covered",
+    "Don't you worry about a thing"
+]
+
+# --- Agent Class ---
+class FrontendPAM:
+    """Frontend PAM - Sweet Southern Receptionist"""
+    
+    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"  # Default user, can be dynamic
+        
+    def _get_endearment(self) -> str:
+        """Get a random term of endearment"""
+        return random.choice(ENDEARMENTS)
+    
+    def _get_greeting(self) -> str:
+        """Get a random warm greeting"""
+        return random.choice(GREETINGS)
+    
+    def _get_comfort_phrase(self) -> str:
+        """Get a random comforting phrase"""
+        return random.choice(COMFORT_PHRASES)
+
+    def _detect_intent(self, text: str) -> str:
+        """Detect user intent using zero-shot classification"""
+        candidate_labels = [
+            "appointment scheduling",
+            "health symptoms inquiry",
+            "resource request",
+            "general question",
+            "emergency concern"
+        ]
+        
+        payload = {
+            "inputs": text,
+            "parameters": {"candidate_labels": candidate_labels}
+        }
+        
+        result = hf_infer("intent", payload)
+        if isinstance(result, dict) and "error" in result:
+            return "general_question"
+        
+        # BART-MNLI returns labels array
+        if isinstance(result, dict) and "labels" in result:
+            return result["labels"][0].replace(" ", "_")
+        
+        return "general_question"
+
+    def _detect_sentiment(self, text: str) -> Dict[str, Any]:
+        """Detect sentiment to gauge emotional state"""
+        result = hf_infer("sentiment", {"inputs": text})
+        if isinstance(result, list) and len(result) > 0:
+            return result[0][0] if isinstance(result[0], list) else result[0]
+        return {"label": "NEUTRAL", "score": 0.5}
+
+    def _generate_response(self, text: str, context: str = "") -> str:
+        """Generate conversational response using LLM"""
+        endearment = self._get_endearment()
+        
+        prompt = f"""<s>[INST] {PAM_TONE}
+
+User said: "{text}"
+{f'Context: {context}' if context else ''}
+
+Respond warmly as PAM, using natural southern charm. Address the user as "{endearment}". [/INST]"""
+
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 150,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "return_full_text": False
+            }
+        }
+        
+        result = hf_infer("chat", payload)
+        
+        if isinstance(result, dict) and "error" in result:
+            return f"Sorry {endearment}, I'm having a little technical hiccup. Could you try that again for me?"
+        
+        if isinstance(result, list) and len(result) > 0:
+            generated = result[0].get("generated_text", "")
+            # Clean up the response
+            reply = generated.strip()
+            # Ensure endearment is included if not already
+            if endearment not in reply.lower():
+                reply = f"{reply.rstrip('.')}  {endearment}."
+            return reply
+        
+        return f"Sorry {endearment}, I didn't quite catch that. Could you say that again?"
+
+    def respond(self, user_text: str, backend_brief: Optional[str] = None) -> Dict[str, Any]:
+        """Main response handler with sweet southern personality"""
+        
+        # Get personalized elements
+        endearment = self._get_endearment()
+        greeting = self._get_greeting()
+        comfort = self._get_comfort_phrase()
+        
+        # Check for PAM greeting (flexible)
+        if not any(trigger in user_text.lower() for trigger in ["hey pam", "hi pam", "hello pam", "pam,"]):
+            return {
+                "reply": f"{greeting} {endearment}! Just a quick note - I respond best when you start with 'Hey PAM' or 'Hi PAM'. It helps me know you're talking to me. 💕"
+            }
+
+        # Clean text for processing
+        text = user_text.lower().replace("pam", "you").strip()
+        
+        # Detect intent and sentiment
+        detected_intent = self._detect_intent(text)
+        sentiment_result = self._detect_sentiment(text)
+        
+        # Check if user seems distressed
+        is_distressed = sentiment_result.get("label") == "NEGATIVE" and sentiment_result.get("score", 0) > 0.7
+        
+        # Permission check (sensitive topics)
+        for term, allowed in self.PERMISSIONS.items():
+            if term.lower() in text and not allowed:
+                return {
+                    "intent": detected_intent,
+                    "sentiment": sentiment_result,
+                    "reply": f"{greeting} {endearment}, that's something I need to connect you with a provider for directly. {comfort}, and I can get you to the right person. Would that be okay?"
+                }
+        
+        # Handle appointments
+        if any(word in text for word in ["appointment", "scheduled", "booking", "schedule"]):
+            appt = self.APPOINTMENTS.get(self.user_id)
+            if appt:
+                appt_date = appt.get('date', 'soon')
+                appt_type = appt.get('type', 'appointment')
+                return {
+                    "intent": "appointment_scheduling",
+                    "sentiment": sentiment_result,
+                    "reply": f"{greeting} {endearment}! You've got a {appt_type} scheduled for {appt_date}. Do you need to reschedule or have any questions about it?"
+                }
+            else:
+                return {
+                    "intent": "appointment_scheduling",
+                    "sentiment": sentiment_result,
+                    "reply": f"{greeting} {endearment}! I don't see any appointments on file for you yet. Would you like me to help you get one set up?"
+                }
+        
+        # Handle health symptoms/concerns
+        symptom_keywords = ["cramp", "pain", "discharge", "bleed", "smell", "spotting", 
+                           "fatigue", "mood", "missed period", "nausea", "concern"]
+        if any(keyword in text for keyword in symptom_keywords):
+            concern_prefix = f"{greeting} {endearment}, I hear you" if is_distressed else f"{greeting} {endearment}"
+            return {
+                "intent": "health_symptoms_inquiry",
+                "sentiment": sentiment_result,
+                "reply": f"{concern_prefix}. I've pulled together some helpful resources about what you're experiencing. Would you like me to also connect you with a nurse for a quick chat?"
+            }
+        
+        # Handle resource requests
+        if any(word in text for word in ["resource", "information", "help", "guide", "link"]):
+            return {
+                "intent": "resource_request",
+                "sentiment": sentiment_result,
+                "reply": f"{greeting} {endearment}! {comfort}. What type of resources are you looking for? I've got information on just about everything."
+            }
+        
+        # Handle emergency indicators
+        emergency_keywords = ["emergency", "urgent", "severe pain", "heavy bleeding", "can't breathe"]
+        if any(keyword in text for keyword in emergency_keywords):
+            return {
+                "intent": "emergency_concern",
+                "sentiment": sentiment_result,
+                "reply": f"{endearment}, if this is a medical emergency, please call 911 or go to your nearest emergency room right away. I'm here for you, but your safety comes first. ❤️"
+            }
+        
+        # General conversational response
+        context = f"Backend summary: {backend_brief}" if backend_brief else ""
+        reply = self._generate_response(user_text, context)
+        
+        return {
+            "intent": detected_intent,
+            "sentiment": sentiment_result,
+            "backend_summary": backend_brief or "No backend data",
+            "reply": reply
+        }
+
+# --- Quick Test ---
+if __name__ == "__main__":
+    pam = load_frontend_agent()
+    test_queries = [
+        "Hey PAM, I have a question about my appointment",
+        "Hi PAM, I'm experiencing some cramping",
+        "Hey PAM, can you help me find resources?"
+    ]
+    
+    print("\n💕 Testing Frontend PAM...\n")
+    for query in test_queries:
+        print(f"USER: {query}")
+        response = pam.respond(query)
+        print(f"PAM: {response['reply']}\n")

logs.json

@@ -0,0 +1,188 @@
+{
+  "latest_logs": [
+    {
+      "id": "log_001",
+      "entry": "Wazuh: Failed SSH login attempt from 192.168.1.101",
+      "timestamp": "2025-11-04T09:13:00",
+      "severity": "CRITICAL",
+      "source": "wazuh",
+      "category": "security",
+      "ip_address": "192.168.1.101",
+      "action_taken": "IP temporarily blocked",
+      "requires_review": true,
+      "tags": ["authentication", "failed_login", "intrusion_attempt"]
+    },
+    {
+      "id": "log_002",
+      "entry": "CloudTrail: IAM role assumed outside working hours",
+      "timestamp": "2025-11-04T11:25:00",
+      "severity": "WARNING",
+      "source": "cloudtrail",
+      "category": "access_control",
+      "user": "admin_user_02",
+      "role": "PowerUserAccess",
+      "action_taken": "Logged for review",
+      "requires_review": true,
+      "tags": ["iam", "after_hours", "unusual_activity"]
+    },
+    {
+      "id": "log_003",
+      "entry": "Wazuh: Unexpected port scanning activity detected",
+      "timestamp": "2025-11-04T14:50:00",
+      "severity": "CRITICAL",
+      "source": "wazuh",
+      "category": "security",
+      "ip_address": "203.0.113.45",
+      "ports_scanned": [22, 80, 443, 3306, 5432],
+      "action_taken": "IP blocked, alert sent to security team",
+      "requires_review": true,
+      "tags": ["port_scan", "reconnaissance", "threat_detected"]
+    },
+    {
+      "id": "log_004",
+      "entry": "Frontend: provider directory unavailable to user session",
+      "timestamp": "2025-11-04T16:02:00",
+      "severity": "WARNING",
+      "source": "frontend",
+      "category": "application",
+      "user_session": "sess_a3f9c21",
+      "affected_feature": "provider_directory",
+      "action_taken": "Session redirected to support",
+      "requires_review": false,
+      "handoff_to_frontend_pam": true,
+      "tags": ["user_facing", "service_unavailable", "ux_issue"]
+    },
+    {
+      "id": "log_005",
+      "entry": "API: Rate limit exceeded for endpoint /ai/chat/",
+      "timestamp": "2025-11-04T17:30:00",
+      "severity": "WARNING",
+      "source": "api_gateway",
+      "category": "performance",
+      "endpoint": "/ai/chat/",
+      "request_count": 150,
+      "rate_limit": 100,
+      "action_taken": "Requests throttled",
+      "requires_review": true,
+      "tags": ["rate_limit", "performance", "api_abuse"]
+    },
+    {
+      "id": "log_006",
+      "entry": "Database: Slow query detected - response time 8.5s",
+      "timestamp": "2025-11-04T18:15:00",
+      "severity": "WARNING",
+      "source": "database",
+      "category": "performance",
+      "query": "SELECT * FROM appointments WHERE...",
+      "response_time": "8.5s",
+      "action_taken": "Query logged for optimization",
+      "requires_review": true,
+      "tags": ["slow_query", "database_performance", "optimization_needed"]
+    },
+    {
+      "id": "log_007",
+      "entry": "Backup: Daily backup completed successfully",
+      "timestamp": "2025-11-04T02:00:00",
+      "severity": "INFO",
+      "source": "backup_service",
+      "category": "maintenance",
+      "backup_size": "2.3GB",
+      "backup_location": "s3://uminur-backups/2025-11-04/",
+      "action_taken": "None - routine operation",
+      "requires_review": false,
+      "tags": ["backup", "routine", "success"]
+    },
+    {
+      "id": "log_008",
+      "entry": "SSL Certificate: Certificate renewal required in 14 days",
+      "timestamp": "2025-11-04T08:00:00",
+      "severity": "WARNING",
+      "source": "certbot",
+      "category": "infrastructure",
+      "domain": "api.uminur.app",
+      "expiration_date": "2025-11-18",
+      "action_taken": "Renewal notification sent",
+      "requires_review": true,
+      "tags": ["ssl", "certificate", "renewal_needed"]
+    },
+    {
+      "id": "log_009",
+      "entry": "Frontend: User reported PHI visible in error message",
+      "timestamp": "2025-11-04T19:45:00",
+      "severity": "CRITICAL",
+      "source": "frontend",
+      "category": "privacy",
+      "incident_id": "INC-2025-1104-001",
+      "action_taken": "Error logs sanitized, incident report created",
+      "requires_review": true,
+      "handoff_to_frontend_pam": true,
+      "tags": ["phi_leak", "privacy_violation", "urgent"]
+    },
+    {
+      "id": "log_010",
+      "entry": "HF Inference API: Model loading timeout for mistral-7b",
+      "timestamp": "2025-11-04T20:30:00",
+      "severity": "WARNING",
+      "source": "api_service",
+      "category": "ai_inference",
+      "model": "mistralai/Mistral-7B-Instruct-v0.2",
+      "timeout": "30s",
+      "retry_count": 3,
+      "action_taken": "Fallback response provided",
+      "requires_review": false,
+      "tags": ["model_loading", "timeout", "inference_error"]
+    },
+    {
+      "id": "log_011",
+      "entry": "Compliance: HIPAA audit check passed",
+      "timestamp": "2025-11-04T06:00:00",
+      "severity": "INFO",
+      "source": "compliance_monitor",
+      "category": "compliance",
+      "audit_type": "hipaa_daily_check",
+      "result": "passed",
+      "action_taken": "None - compliant",
+      "requires_review": false,
+      "tags": ["hipaa", "compliance", "audit"]
+    },
+    {
+      "id": "log_012",
+      "entry": "Nginx: Unauthorized access attempt to /admin endpoint",
+      "timestamp": "2025-11-04T21:10:00",
+      "severity": "CRITICAL",
+      "source": "nginx",
+      "category": "security",
+      "ip_address": "198.51.100.23",
+      "endpoint": "/admin",
+      "status_code": 403,
+      "action_taken": "Access denied, IP logged",
+      "requires_review": true,
+      "tags": ["unauthorized_access", "admin_endpoint", "security_threat"]
+    }
+  ],
+  "log_summary": {
+    "total_entries": 12,
+    "critical": 4,
+    "warning": 5,
+    "info": 3,
+    "requires_review": 8,
+    "handoff_to_frontend": 2,
+    "time_range": {
+      "start": "2025-11-04T02:00:00",
+      "end": "2025-11-04T21:10:00"
+    },
+    "top_categories": [
+      "security",
+      "performance",
+      "compliance",
+      "privacy"
+    ]
+  },
+  "alert_thresholds": {
+    "critical_alerts_per_hour": 2,
+    "failed_login_attempts": 5,
+    "port_scan_tolerance": 0,
+    "phi_leak_tolerance": 0,
+    "rate_limit_threshold": 100
+  }
+}

permissions.json

@@ -0,0 +1,41 @@
+{
+  "sensitive_topics": {
+    "abortion": false,
+    "sexual_assault": false,
+    "domestic_violence": false,
+    "self_harm": false,
+    "substance_abuse": false,
+    "mental_health_crisis": false
+  },
+  "medical_services": {
+    "hormone_therapy": true,
+    "birth_control": true,
+    "fertility_treatment": true,
+    "prenatal_care": true,
+    "std_testing": true,
+    "cancer_screening": true,
+    "menopause_management": true
+  },
+  "general_health": {
+    "nutrition_guidance": true,
+    "exercise_recommendations": true,
+    "symptom_checker": true,
+    "medication_info": true,
+    "appointment_scheduling": true,
+    "lab_results_explanation": true
+  },
+  "emergency_topics": {
+    "severe_bleeding": true,
+    "chest_pain": true,
+    "difficulty_breathing": true,
+    "loss_of_consciousness": true,
+    "severe_abdominal_pain": true,
+    "suicidal_thoughts": false
+  },
+  "policy": {
+    "description": "Topics marked 'false' require immediate escalation to a licensed provider or crisis hotline",
+    "false_action": "redirect_to_provider",
+    "escalation_message": "connect you with a provider or safe resource who can help with this directly",
+    "always_available": ["appointment_scheduling", "general_questions", "resource_navigation"]
+  }
+}

requirements.txt

@@ -0,0 +1,50 @@
+# filename: requirements.txt
+# PAM - Privacy-First AI Assistant
+# Optimized for Hugging Face Spaces (CPU deployment)
+
+# ==========================================
+# Web Server / API Framework
+# ==========================================
+fastapi>=0.104.0,<0.110.0
+uvicorn[standard]>=0.23.2,<0.30.0
+pydantic>=2.4.2,<3.0.0
+python-multipart>=0.0.6
+starlette>=0.35.1,<0.40.0
+
+# ==========================================
+# HTTP & API Communication
+# ==========================================
+requests>=2.31.0
+httpx>=0.25.0
+
+# ==========================================
+# AI/ML Libraries (CPU-optimized)
+# ==========================================
+# NOTE: Transformers is only needed if using local pipelines
+# For HF Inference API (recommended for Spaces), it's optional
+# transformers>=4.35.0,<4.40.0
+# torch>=2.1.0,<2.2.0  # REMOVED - not needed for Inference API
+
+# Transformers without torch dependency (for tokenizers only if needed)
+transformers>=4.35.0,<4.40.0
+# Install CPU-only torch if you absolutely need local models
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch>=2.1.0,<2.3.0
+
+# ==========================================
+# Utilities & Data Processing
+# ==========================================
+python-dateutil>=2.8.2
+pytz>=2023.3
+
+# ==========================================
+# Optional: AWS Integration (if needed)
+# ==========================================
+# boto3>=1.28.69  # Uncomment if using AWS services
+
+# ==========================================
+# Development & Debugging (remove in production)
+# ==========================================
+# pytest>=7.4.0
+# black>=23.10.0
+# flake8>=6.1.0

resources.json

@@ -0,0 +1,297 @@
+{
+  "symptoms": {
+    "discharge": {
+      "title": "Vaginal Discharge Information",
+      "resources": [
+        {
+          "type": "guide",
+          "title": "What Different Colors of Discharge Mean",
+          "url": "https://www.uminur.app/resources/discharge-guide",
+          "description": "Learn what's normal and when to see a provider"
+        },
+        {
+          "type": "article",
+          "title": "Understanding Vaginal Health",
+          "url": "https://www.uminur.app/resources/vaginal-health",
+          "description": "Comprehensive guide to vaginal health and hygiene"
+        },
+        {
+          "type": "provider",
+          "title": "Find a Gynecologist",
+          "url": "https://www.uminur.app/find-a-doctor",
+          "description": "Connect with a women's health specialist"
+        }
+      ],
+      "keywords": ["discharge", "vaginal", "secretion", "leaking", "wetness"]
+    },
+    "cramps": {
+      "title": "Menstrual Cramps & Pelvic Pain",
+      "resources": [
+        {
+          "type": "video",
+          "title": "Stretching Exercises for Cramp Relief",
+          "url": "https://www.uminur.app/resources/cramp-relief-video",
+          "description": "5-minute stretches that can ease period pain",
+          "duration": "5 min"
+        },
+        {
+          "type": "article",
+          "title": "When Cramps Could Mean Something Serious",
+          "url": "https://www.uminur.app/resources/severe-cramps",
+          "description": "Signs that warrant medical attention"
+        },
+        {
+          "type": "guide",
+          "title": "Heat Therapy & Pain Management",
+          "url": "https://www.uminur.app/resources/pain-management",
+          "description": "Natural and medical options for relief"
+        },
+        {
+          "type": "provider",
+          "title": "Find a Provider",
+          "url": "https://www.uminur.app/providers",
+          "description": "Book an appointment for persistent pain"
+        }
+      ],
+      "keywords": ["cramps", "cramping", "pain", "pelvic pain", "period pain", "menstrual pain"]
+    },
+    "fatigue": {
+      "title": "Managing Fatigue & Low Energy",
+      "resources": [
+        {
+          "type": "article",
+          "title": "Period Fatigue: Why It Happens",
+          "url": "https://www.uminur.app/resources/period-fatigue",
+          "description": "Understanding the hormonal causes of tiredness"
+        },
+        {
+          "type": "guide",
+          "title": "Nutritional Support for Energy",
+          "url": "https://www.uminur.app/resources/nutrition-energy",
+          "description": "Foods that help combat period-related fatigue"
+        },
+        {
+          "type": "tips",
+          "title": "Sleep Hygiene During Your Cycle",
+          "url": "https://www.uminur.app/resources/sleep-tips",
+          "description": "Better sleep strategies for hormone fluctuations"
+        },
+        {
+          "type": "provider",
+          "title": "Talk to a Specialist",
+          "url": "https://www.uminur.app/providers",
+          "description": "Rule out anemia or other conditions"
+        }
+      ],
+      "keywords": ["fatigue", "tired", "exhausted", "low energy", "weakness", "sluggish"]
+    },
+    "mood": {
+      "title": "Mood Changes & Emotional Wellness",
+      "resources": [
+        {
+          "type": "video",
+          "title": "Navigating Mood Swings",
+          "url": "https://www.uminur.app/resources/mood-swings-video",
+          "description": "Understanding PMS and PMDD",
+          "duration": "8 min"
+        },
+        {
+          "type": "article",
+          "title": "Hormones and Your Emotions",
+          "url": "https://www.uminur.app/resources/hormones-emotions",
+          "description": "The science behind cycle-related mood changes"
+        },
+        {
+          "type": "guide",
+          "title": "Coping Strategies for PMS",
+          "url": "https://www.uminur.app/resources/pms-coping",
+          "description": "Practical tools for emotional regulation"
+        },
+        {
+          "type": "community",
+          "title": "Join Support Groups",
+          "url": "https://www.uminur.app/community",
+          "description": "Connect with others experiencing similar challenges"
+        }
+      ],
+      "keywords": ["mood", "moody", "emotional", "irritable", "anxiety", "depression", "crying", "pms"]
+    },
+    "missed_period": {
+      "title": "Missed Period Information",
+      "resources": [
+        {
+          "type": "article",
+          "title": "Causes of a Missed Period",
+          "url": "https://www.uminur.app/resources/missed-period-causes",
+          "description": "Beyond pregnancy: stress, hormones, and health"
+        },
+        {
+          "type": "guide",
+          "title": "Should I Take a Pregnancy Test?",
+          "url": "https://www.uminur.app/resources/pregnancy-check",
+          "description": "When and how to test accurately"
+        },
+        {
+          "type": "article",
+          "title": "Irregular Cycles: What's Normal?",
+          "url": "https://www.uminur.app/resources/irregular-cycles",
+          "description": "Understanding cycle variations"
+        },
+        {
+          "type": "provider",
+          "title": "Find a Provider",
+          "url": "https://www.uminur.app/find-a-doctor",
+          "description": "Get professional guidance"
+        }
+      ],
+      "keywords": ["missed period", "late period", "no period", "amenorrhea", "irregular"]
+    },
+    "bleeding": {
+      "title": "Bleeding & Spotting",
+      "resources": [
+        {
+          "type": "article",
+          "title": "Understanding Spotting",
+          "url": "https://www.uminur.app/resources/spotting-guide",
+          "description": "Common causes and when to worry"
+        },
+        {
+          "type": "guide",
+          "title": "Heavy Bleeding: When to Seek Help",
+          "url": "https://www.uminur.app/resources/heavy-bleeding",
+          "description": "Signs of menorrhagia and treatment options"
+        },
+        {
+          "type": "provider",
+          "title": "Find a Provider",
+          "url": "https://www.uminur.app/providers",
+          "description": "Schedule a consultation"
+        }
+      ],
+      "keywords": ["bleeding", "spotting", "heavy period", "hemorrhage", "blood clots"]
+    },
+    "nausea": {
+      "title": "Nausea & Digestive Issues",
+      "resources": [
+        {
+          "type": "article",
+          "title": "Period-Related Nausea",
+          "url": "https://www.uminur.app/resources/period-nausea",
+          "description": "Why periods can cause stomach upset"
+        },
+        {
+          "type": "tips",
+          "title": "Managing Nausea Naturally",
+          "url": "https://www.uminur.app/resources/nausea-relief",
+          "description": "Foods and remedies that help"
+        },
+        {
+          "type": "provider",
+          "title": "Talk to a Provider",
+          "url": "https://www.uminur.app/providers",
+          "description": "If nausea is severe or persistent"
+        }
+      ],
+      "keywords": ["nausea", "sick", "vomiting", "queasy", "stomach upset"]
+    }
+  },
+  "general_health": {
+    "birth_control": {
+      "title": "Birth Control Options",
+      "resources": [
+        {
+          "type": "guide",
+          "title": "Complete Birth Control Guide",
+          "url": "https://www.uminur.app/resources/birth-control-options",
+          "description": "Compare methods, effectiveness, and side effects"
+        },
+        {
+          "type": "quiz",
+          "title": "Find Your Best Option",
+          "url": "https://www.uminur.app/tools/birth-control-quiz",
+          "description": "Interactive tool to match your lifestyle"
+        },
+        {
+          "type": "provider",
+          "title": "Schedule a Consultation",
+          "url": "https://www.uminur.app/appointments/birth-control",
+          "description": "Discuss options with a provider"
+        }
+      ]
+    },
+    "pregnancy": {
+      "title": "Pregnancy & Prenatal Care",
+      "resources": [
+        {
+          "type": "guide",
+          "title": "First Trimester Guide",
+          "url": "https://www.uminur.app/resources/first-trimester",
+          "description": "What to expect in early pregnancy"
+        },
+        {
+          "type": "checklist",
+          "title": "Prenatal Care Checklist",
+          "url": "https://www.uminur.app/resources/prenatal-checklist",
+          "description": "Important appointments and screenings"
+        },
+        {
+          "type": "provider",
+          "title": "Find an OB/GYN",
+          "url": "https://www.uminur.app/find-obgyn",
+          "description": "Connect with prenatal care"
+        }
+      ]
+    },
+    "sti_testing": {
+      "title": "STI Testing & Sexual Health",
+      "resources": [
+        {
+          "type": "article",
+          "title": "STI Testing: What You Need to Know",
+          "url": "https://www.uminur.app/resources/sti-testing",
+          "description": "Types of tests and when to get screened"
+        },
+        {
+          "type": "guide",
+          "title": "Sexual Health & Wellness",
+          "url": "https://www.uminur.app/resources/sexual-health",
+          "description": "Comprehensive sexual health information"
+        },
+        {
+          "type": "provider",
+          "title": "Confidential Testing",
+          "url": "https://www.uminur.app/services/sti-testing",
+          "description": "Private, judgment-free testing"
+        }
+      ]
+    }
+  },
+  "emergency": {
+    "hotlines": [
+      {
+        "name": "National Suicide Prevention Lifeline",
+        "phone": "988",
+        "url": "https://988lifeline.org",
+        "available": "24/7"
+      },
+      {
+        "name": "National Domestic Violence Hotline",
+        "phone": "1-800-799-7233",
+        "url": "https://www.thehotline.org",
+        "available": "24/7"
+      },
+      {
+        "name": "RAINN Sexual Assault Hotline",
+        "phone": "1-800-656-4673",
+        "url": "https://www.rainn.org",
+        "available": "24/7"
+      },
+      {
+        "name": "Substance Abuse Helpline",
+        "phone": "1-800-662-4357",
+        "url": "https://www.samhsa.gov",
+        "available": "24/7"
+      }
+    ]
+  }
+}