Upload 7 files

.dockerignore

@@ -0,0 +1,15 @@
+venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.coverage
+htmlcov/
+data/raw/*
+data/processed/*
+data/predictions/*
+!data/raw/.gitkeep
+!data/processed/.gitkeep
+!data/predictions/.gitkeep
+models/*
+artifacts/*
+.env

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Non-root user
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONPATH=/home/user/app
+WORKDIR $HOME/app
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . .
+
+EXPOSE 7860
+CMD ["python", "app.py"]

README.md

@@ -1,11 +1,131 @@
+# 🛡️ SentinelAI: Enterprise Security Intelligence Platform
+
+![SentinelAI](https://img.shields.io/badge/Status-Hackathon_Ready-00E676?style=for-the-badge)
+![Python](https://img.shields.io/badge/Python-3.10+-blue?style=for-the-badge)
+![Streamlit](https://img.shields.io/badge/Streamlit-Dark_Theme-FF4B4B?style=for-the-badge)
+
+SentinelAI is an end-to-end, multi-stage AI security platform designed to move beyond simple anomaly detection. It actively learns normal behavior, detects deviations using an ensemble of models, accurately classifies attack vectors, and explains its reasoning in human-readable terms on a premium analyst dashboard.
+
+### 🖼️ Dashboard Previews
+| Global Telemetry | Threat Hunting | Deep Investigation |
+| :---: | :---: | :---: |
+| ![Global Telemetry](https://via.placeholder.com/400x200.png?text=Global+Telemetry) | ![Threat Queue](https://via.placeholder.com/400x200.png?text=Threat+Hunting+Queue) | ![Investigation Console](https://via.placeholder.com/400x200.png?text=Deep+Investigation) |
+
+---
+
+## 🏆 How We Meet the Evaluation Criteria
+
+This project was specifically architected to address the complex requirements of modern enterprise security. **We did not just train an Isolation Forest; we built a comprehensive intelligence pipeline.**
+
+| Evaluation Criteria | How SentinelAI Solves It |
+| :--- | :--- |
+| **Behavior Profiling** | **Phase 2 Pipeline** generates passive statistical baselines for devices and users to understand "normal" before scoring deviations. |
+| **Detect Deviations** | **Phase 3 Pipeline** utilizes a Detection Aggregator combining deterministic rules, statistical deviations, and an Isolation Forest. |
+| **Attack Classification** | **Phase 4 Pipeline** feeds aggregated anomalies into an `XGBoostClassifier` to identify specific threat vectors (e.g., Credential Stuffing, Brute Force). |
+| **Explain Why (XAI)** | **Phase 5 Pipeline** uses `SHAP` for feature importance and a `NaturalLanguageGenerator` to output actionable, human-readable executive summaries. |
+| **Low False Positives** | Our **Risk Fusion Engine** acts as a filter. By ensembling multiple distinct engines (Rules + Stats + IF), we suppress noisy, single-engine alerts. |
+| **Imbalanced Data** | `XGBoost` naturally handles severe class imbalance via weight scaling, while our `Isolation Forest` operates as an unsupervised outlier detector. |
+| **Cold Start Handling** | New users have no profile. Our **Rule Engine** covers the cold start phase with strict heuristics until the statistical engines gather enough data to take over. |
+| **Concept Drift** | The modular `orchestrator.py` architecture allows passive models to be periodically retrained on new parquet chunks without taking the detection rules offline. |
+| **Scalability** | The entire backend operates on highly optimized `parquet` files using Pandas/PyArrow, ready for distributed processing. |
+| **Dashboard Usability** | We built a responsive, premium Streamlit dashboard featuring custom CSS, dark mode, and interactive Plotly visualizations for rapid threat investigation. |
+
+---
+
+## 🧠 Core Architecture Pipeline
+
+SentinelAI operates on a strict, 5-phase execution pipeline to ensure maximum fidelity and explainability.
+
+```mermaid
+graph TD
+    A[Synthetic Data Generation] --> B[Feature Engineering]
+    B --> C[Behavior Profiling]
+    C --> D[Isolation Forest]
+    C --> E[Rule Engine]
+    D --> F[Risk Fusion Engine]
+    E --> F
+    F --> G[XGBoost Classifier]
+    G --> H[SHAP Explainability]
+    H --> I[SOC Analyst Dashboard]
+    
+    style I fill:#2196F3,stroke:#333,stroke-width:2px,color:#fff
+```
+
+1. **Data Ingestion & Generation:** Bootstraps baseline enterprise logs and injects precise threat scenarios (e.g. Impossible Travel).
+2. **Feature Engineering & Profiling:** Temporal and behavioral feature extraction.
+3. **Detection Core (The Ensemble):**
+    - **Rule Engine:** Deterministic checks (e.g., impossible travel, mass failures).
+    - **Statistical Engine:** Checks against established user/device baselines.
+    - **Isolation Forest:** High-dimensional anomaly detection.
+4. **Risk Fusion & Classification:** Normalizes inputs into an enterprise 0-100 risk score and uses XGBoost to classify the exact threat context.
+5. **Explainability Engine:** Generates SHAP values, risk breakdowns, and natural language audit trails.
+
+---
+
+## 🚀 How to Run the Project (For Judges)
+
+We've made reproducibility our top priority. You can run the entire pipeline and view the dashboard with just a few commands.
+
+### 1. Setup Environment
+```bash
+python -m venv venv
+source venv/Scripts/activate  # On Windows
+pip install -r requirements.txt
+```
+
+### 2. Local Execution (Analyst Dashboard)
+Our Streamlit app is the primary interface for the platform.
+```bash
+streamlit run src/ui/app.py
+```
+
+### 3. Final Demo Mode (Execute Pipeline)
+You can trigger the entire end-to-end AI pipeline (Phases 1 through 5) directly from the **sidebar of the Streamlit Dashboard** by clicking **"🚀 Execute AI Pipeline"**. 
+
+Alternatively, you can run it headless from the terminal:
+```bash
+python -m src.runtime.orchestrator
+```
+
+### 4. Docker Execution
+To run SentinelAI in an isolated container:
+```bash
+docker-compose up --build
+```
+The dashboard will be accessible at `http://localhost:8501`.
+
+### 5. Hugging Face Deployment
+To deploy to Hugging Face Spaces:
+1. Create a new Space (choose Streamlit as the SDK).
+2. Upload the repository files.
+3. Hugging Face will automatically install `requirements.txt` and run `app.py`.
+
+---
+
+## 🛠️ Configuration & Troubleshooting
+
+- **Configuration:** Environment settings are stored in the `config/` directory. You can toggle feature flags in `config/feature_flags/`.
+- **Troubleshooting:** 
+  - *No Data Displayed:* Ensure you click "Execute AI Pipeline" in the sidebar to generate data.
+  - *ModuleNotFoundError:* Ensure your `PYTHONPATH` includes the project root, or always run scripts as modules (e.g., `python -m src.ui.app`).
+
 ---
-title: SentinelAI
-emoji: 🐠
-colorFrom: gray
-colorTo: gray
-sdk: static
-pinned: false
-short_description: AI-Powered Behavioral Threat Detection Platform
+
+## 📁 Repository Structure
+
+```text
+SentinelAI/
+├── src/
+│   ├── ai/               # Core Intelligence (Detection, Classification, XAI)
+│   ├── data/             # Data Generation & Validation
+│   ├── runtime/          # Pipeline Orchestrators (Phases 2-5)
+│   └── ui/               # Streamlit Dashboard & Plotly Visualizations
+├── data/                 # Raw, Processed, and Prediction parquets
+├── docs/                 # Enterprise Documentation & Final Submission Reports
+├── models/               # Serialized models (XGBoost, Isolation Forest)
+├── .streamlit/           # Premium UI Configurations
+└── README.md             # You are here!
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,22 @@
+import os
+import subprocess
+import sys
+
+def main():
+    os.environ["STREAMLIT_CONFIG_DIR"] = os.path.join(os.getcwd(), ".streamlit")
+    os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+    os.environ["STREAMLIT_HEADLESS"] = "true"
+    os.environ["PYTHONPATH"] = os.getcwd()
+    print("Starting SentinelAI Application via Hugging Face Entrypoint...")
+    
+    # 1. Run Pipeline Orchestrator if data doesn't exist
+    if not os.path.exists("data/predictions/explanations.parquet"):
+        print("Running pipeline to generate data...")
+        subprocess.run([sys.executable, "-m", "src.runtime.orchestrator"], check=True)
+        
+    # 2. Launch Streamlit
+    print("Launching Streamlit Dashboard...")
+    subprocess.run([sys.executable, "-m", "streamlit", "run", "src/ui/app.py", "--server.port=7860", "--server.address=0.0.0.0", "--browser.gatherUsageStats=false", "--server.headless=true"])
+
+if __name__ == "__main__":
+    main()

docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3.8'
+
+services:
+  sentinelai:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - PYTHONUNBUFFERED=1
+    volumes:
+      - ./data:/home/user/app/data
+      - ./artifacts:/home/user/app/artifacts
+      - ./models:/home/user/app/models

requirements.txt

@@ -0,0 +1,22 @@
+# Data and Persistence
+pandas>=2.1.0
+numpy>=1.26.0
+pyarrow>=14.0.0
+fastparquet>=2023.10.0
+
+# AI and Machine Learning
+scikit-learn>=1.3.0
+xgboost>=2.0.0
+shap>=0.44.0
+
+# Dashboard and Visualization
+streamlit>=1.30.0
+plotly>=5.18.0
+
+# Utilities
+pyyaml>=6.0
+python-dotenv>=1.0.0
+faker>=22.0.0
+
+# Testing
+pytest>=7.4.0