Upload folder using huggingface_hub

README.md

@@ -1,6 +1,6 @@
 ---
-title: CyberSec Models Demo
-emoji: "\U0001F6E1\uFE0F"
+title: CyberSec Models - Advanced Demo
+emoji: 🛡️
 colorFrom: red
 colorTo: purple
 sdk: gradio
@@ -14,31 +14,89 @@ tags:
 - rgpd
 - gdpr
 - compliance
+- rag
 - fine-tuned
+- streaming
 models:
 - AYI-NEDJIMI/CyberSec-Assistant-3B
 - AYI-NEDJIMI/ISO27001-Expert-1.5B
 - AYI-NEDJIMI/RGPD-Expert-1.5B
+datasets:
+- AYI-NEDJIMI/iso27001
+- AYI-NEDJIMI/rgpd-fr
+- AYI-NEDJIMI/gdpr-en
+- AYI-NEDJIMI/mitre-attack-fr
+- AYI-NEDJIMI/owasp-top10-fr
+- AYI-NEDJIMI/nis2-directive-fr
 ---
 
-# CyberSec AI Models Demo
+# 🛡️ CyberSec AI Models - Advanced Demo
 
-Interactive demo for three fine-tuned cybersecurity language models built on the Qwen2.5 architecture.
+**Advanced interactive demo showcasing 3 fine-tuned cybersecurity AI models with RAG and streaming.**
+
+## Features
+
+### 💬 Chat Mode
+- Select from 3 specialized models
+- Enable RAG (Retrieval-Augmented Generation) for context from 80+ datasets
+- Streaming responses (token-by-token generation)
+- Adjustable temperature and max tokens
+- Multi-turn conversations with full history
+
+### ⚖️ Compare Mode
+- Ask the same question to all 3 models simultaneously
+- See side-by-side responses
+- Identify each model's strengths and specializations
+- Compare with or without RAG
+
+### 🔍 RAG (Retrieval-Augmented Generation)
+- Semantic search across 80+ cybersecurity datasets
+- Top-k document retrieval using sentence-transformers
+- Automatic context injection for more accurate, detailed answers
+- Sources include: ISO 27001, RGPD/GDPR, MITRE ATT&CK, OWASP, NIS2, and more
 
 ## Models
 
 | Model | Base | Parameters | Specialty |
 |-------|------|------------|-----------|
-| **CyberSec Assistant 3B** | Qwen2.5-3B-Instruct | 3B | General cybersecurity, compliance, pentesting, SOC |
-| **ISO 27001 Expert 1.5B** | Qwen2.5-1.5B-Instruct | 1.5B | ISO/IEC 27001 ISMS |
-| **RGPD Expert 1.5B** | Qwen2.5-1.5B-Instruct | 1.5B | GDPR / RGPD data protection |
+| [ISO27001-Expert-1.5B](https://huggingface.co/AYI-NEDJIMI/ISO27001-Expert-1.5B) | Qwen2.5-1.5B-Instruct | 1.5B | ISO/IEC 27001 ISMS implementation, controls, auditing |
+| [RGPD-Expert-1.5B](https://huggingface.co/AYI-NEDJIMI/RGPD-Expert-1.5B) | Qwen2.5-1.5B-Instruct | 1.5B | GDPR/RGPD compliance, data protection, DPO guidance |
+| [CyberSec-Assistant-3B](https://huggingface.co/AYI-NEDJIMI/CyberSec-Assistant-3B) | Qwen2.5-3B-Instruct | 3B | General cybersecurity, pentesting, SOC, compliance |
+
+All models are fine-tuned with **QLoRA (4-bit quantization)** on specialized cybersecurity datasets.
+
+## Technical Details
 
-All models are PEFT/LoRA adapters fine-tuned on domain-specific cybersecurity datasets.
+- **Fine-tuning method**: QLoRA (LoRA rank=64, alpha=128)
+- **Training data**: 80+ bilingual (FR/EN) cybersecurity datasets
+- **RAG embedding**: sentence-transformers/all-MiniLM-L6-v2
+- **Inference**: CPU with float32 (Hugging Face free tier)
+- **Streaming**: TextIteratorStreamer for real-time token generation
 
-## Usage
+## Use Cases
 
-Select a model from the dropdown and start chatting. The 1.5B models are loaded by default on CPU Spaces. The 3B model requires more memory and may be slow on free-tier CPU hardware.
+- **ISO 27001 compliance**: Implementation guidance, control selection, audit preparation
+- **GDPR/RGPD compliance**: Data protection requirements, DPIA, breach notification
+- **Cybersecurity research**: MITRE ATT&CK, OWASP, threat hunting, SOC operations
+- **Training & education**: Interactive Q&A for cybersecurity professionals
+- **Compliance assessment**: Compare regulatory frameworks (NIS2, DORA, AI Act)
+
+## Performance Notes
+
+⚠️ **Running on CPU**: First response takes 30-60 seconds while models load. Subsequent responses are faster but still slower than GPU inference.
+
+💡 **Tip**: The 1.5B models (ISO27001 and RGPD) are more responsive on CPU. The 3B model may be slower.
 
 ## Author
 
-**AYI-NEDJIMI** — [HuggingFace Profile](https://huggingface.co/AYI-NEDJIMI)
+**Ayi NEDJIMI** - Senior Offensive Cybersecurity & AI Consultant
+
+- 🌐 [Website](https://www.ayinedjimi-consultants.fr)
+- 💼 [LinkedIn](https://www.linkedin.com/in/ayi-nedjimi)
+- 🐙 [GitHub](https://github.com/ayinedjimi)
+- 🐦 [Twitter/X](https://x.com/AyiNEDJIMI)
+- 🤗 [HuggingFace Collection](https://huggingface.co/collections/AYI-NEDJIMI/cybersec-ai-portfolio-datasets-models-and-spaces-699224074a478ec0feeac493)
+
+## License
+
+Apache 2.0

app.py

@@ -1,11 +1,17 @@
 import gc
+import json
 import os
 import threading
+from pathlib import Path
+from typing import Generator
 
 import gradio as gr
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
 from peft import PeftModel
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from datasets import load_dataset
 
 # ---------------------------------------------------------------------------
 # Model registry
@@ -27,7 +33,6 @@ MODELS = {
             "Explain the Statement of Applicability (SoA).",
             "What changed between ISO 27001:2013 and ISO 27001:2022?",
         ],
-        "size_warning": None,
     },
     "RGPD Expert (1.5B)": {
         "base": "Qwen/Qwen2.5-1.5B-Instruct",
@@ -45,7 +50,6 @@ MODELS = {
             "Explain the right to data portability.",
             "What are the penalties for GDPR non-compliance?",
         ],
-        "size_warning": None,
     },
     "CyberSec Assistant (3B)": {
         "base": "Qwen/Qwen2.5-3B-Instruct",
@@ -61,50 +65,104 @@ MODELS = {
             "Explain the NIS2 directive requirements.",
             "What are the OWASP Top 10 for 2024?",
         ],
-        "size_warning": (
-            "Warning: The 3B model requires ~6 GB RAM. On free CPU Spaces "
-            "it may be slow or run out of memory. The 1.5B models are recommended."
-        ),
     },
 }
 
-DEFAULT_MODEL = "ISO 27001 Expert (1.5B)"
-
 # ---------------------------------------------------------------------------
-# Global state
+# RAG Setup
 # ---------------------------------------------------------------------------
-_lock = threading.Lock()
-_current_model_name: str | None = None
-_tokenizer = None
-_model = None
-
-
-def _unload_model():
-    """Release the currently loaded model and free memory."""
-    global _model, _tokenizer, _current_model_name
-    _model = None
-    _tokenizer = None
-    _current_model_name = None
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-
+class RAGRetriever:
+    """Simple RAG retriever using sentence-transformers and in-memory index."""
+
+    def __init__(self):
+        self.embedder = None
+        self.documents = []
+        self.embeddings = None
+        self.initialized = False
+
+    def initialize(self):
+        """Load embedding model and build index from datasets."""
+        if self.initialized:
+            return
 
-def _load_model(model_name: str):
-    """Load base model + LoRA adapter. Call under _lock."""
-    global _model, _tokenizer, _current_model_name
+        print("Initializing RAG retriever...")
+        self.embedder = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+
+        # Load key datasets (subset for demo - full 80 datasets would be too heavy)
+        dataset_ids = [
+            "AYI-NEDJIMI/iso27001",
+            "AYI-NEDJIMI/rgpd-fr",
+            "AYI-NEDJIMI/gdpr-en",
+            "AYI-NEDJIMI/mitre-attack-fr",
+            "AYI-NEDJIMI/owasp-top10-fr",
+            "AYI-NEDJIMI/nis2-directive-fr",
+        ]
+
+        print(f"Loading {len(dataset_ids)} datasets for RAG...")
+        for ds_id in dataset_ids:
+            try:
+                ds = load_dataset(ds_id, split="train")
+                for item in ds:
+                    # Extract text content
+                    if "output" in item:
+                        text = f"{item.get('instruction', '')}\n{item['output']}"
+                    elif "response" in item:
+                        text = f"{item.get('question', '')}\n{item['response']}"
+                    elif "text" in item:
+                        text = item["text"]
+                    else:
+                        continue
+
+                    self.documents.append({
+                        "text": text[:1000],  # Limit length
+                        "source": ds_id.split("/")[-1],
+                    })
+            except Exception as e:
+                print(f"Failed to load {ds_id}: {e}")
+
+        print(f"Loaded {len(self.documents)} documents. Creating embeddings...")
+        texts = [doc["text"] for doc in self.documents]
+        self.embeddings = self.embedder.encode(texts, show_progress_bar=True)
+        self.initialized = True
+        print("RAG retriever ready!")
+
+    def retrieve(self, query: str, top_k: int = 3) -> list[dict]:
+        """Retrieve top-k most relevant documents."""
+        if not self.initialized:
+            return []
+
+        query_emb = self.embedder.encode([query])[0]
+        similarities = np.dot(self.embeddings, query_emb)
+        top_indices = np.argsort(similarities)[::-1][:top_k]
+
+        results = []
+        for idx in top_indices:
+            results.append({
+                "text": self.documents[idx]["text"],
+                "source": self.documents[idx]["source"],
+                "score": float(similarities[idx]),
+            })
+        return results
+
+
+# Global RAG instance
+rag_retriever = RAGRetriever()
 
-    if _current_model_name == model_name:
-        return  # already loaded
+# ---------------------------------------------------------------------------
+# Global model state
+# ---------------------------------------------------------------------------
+_lock = threading.Lock()
+_loaded_models = {}  # Cache loaded models
 
-    _unload_model()
+def _load_model_cached(model_name: str):
+    """Load model with caching. Returns (tokenizer, model)."""
+    if model_name in _loaded_models:
+        return _loaded_models[model_name]
 
     cfg = MODELS[model_name]
-    hf_token = os.getenv("HF_TOKEN", None)
+    hf_token = os.getenv("HF_TOKEN")
 
-    dtype = torch.float32  # CPU-safe default
-
-    _tokenizer = AutoTokenizer.from_pretrained(
+    tokenizer = AutoTokenizer.from_pretrained(
         cfg["base"],
         trust_remote_code=True,
         token=hf_token,
@@ -112,101 +170,149 @@ def _load_model(model_name: str):
 
     base = AutoModelForCausalLM.from_pretrained(
         cfg["base"],
-        torch_dtype=dtype,
+        torch_dtype=torch.float32,
         device_map="cpu",
         trust_remote_code=True,
         token=hf_token,
     )
 
-    _model = PeftModel.from_pretrained(
+    model = PeftModel.from_pretrained(
         base,
         cfg["adapter"],
-        torch_dtype=dtype,
+        torch_dtype=torch.float32,
         token=hf_token,
     )
-    _model.eval()
-    _current_model_name = model_name
+    model.eval()
+
+    _loaded_models[model_name] = (tokenizer, model)
+    return tokenizer, model
 
 
 # ---------------------------------------------------------------------------
-# Chat function
+# Response generation
 # ---------------------------------------------------------------------------
-def respond(message: str, history: list[dict], model_name: str):
-    """Generate a response from the selected model."""
+def generate_response(
+    message: str,
+    history: list[dict],
+    model_name: str,
+    use_rag: bool,
+    temperature: float,
+    max_tokens: int,
+) -> Generator[str, None, None]:
+    """Generate response with streaming."""
+
     if not message.strip():
         yield ""
         return
 
     cfg = MODELS[model_name]
 
-    # Show warning for large model
-    if cfg["size_warning"]:
-        yield f"*{cfg['size_warning']}*\n\nLoading model, please wait..."
-    else:
-        yield "Loading model, please wait..."
+    # RAG retrieval
+    rag_context = ""
+    if use_rag:
+        yield "🔍 Searching knowledge base...\n\n"
+        if not rag_retriever.initialized:
+            rag_retriever.initialize()
+
+        docs = rag_retriever.retrieve(message, top_k=3)
+        if docs:
+            rag_context = "\n\n**Relevant context from knowledge base:**\n"
+            for i, doc in enumerate(docs, 1):
+                rag_context += f"\n[{i}] From {doc['source']} (relevance: {doc['score']:.2f}):\n{doc['text'][:300]}...\n"
+            rag_context += "\n---\n\n"
+
+    # Load model
+    yield f"{rag_context}Loading {model_name}...\n\n"
 
     with _lock:
         try:
-            _load_model(model_name)
-        except Exception as exc:
-            yield f"**Error loading model:** {exc}"
+            tokenizer, model = _load_model_cached(model_name)
+        except Exception as e:
+            yield f"{rag_context}**Error loading model:** {e}"
             return
 
-    # Build messages in ChatML style
-    messages = [{"role": "system", "content": cfg["system_prompt"]}]
+    # Build prompt
+    system_msg = cfg["system_prompt"]
+    if use_rag and docs:
+        system_msg += "\n\nYou have access to relevant excerpts from the knowledge base. Use them to provide accurate, detailed answers."
+
+    messages = [{"role": "system", "content": system_msg}]
     for entry in history:
         messages.append({"role": entry["role"], "content": entry["content"]})
     messages.append({"role": "user", "content": message})
 
-    input_text = _tokenizer.apply_chat_template(
+    input_text = tokenizer.apply_chat_template(
         messages, tokenize=False, add_generation_prompt=True
     )
-    inputs = _tokenizer(input_text, return_tensors="pt").to("cpu")
-
-    with torch.no_grad():
-        outputs = _model.generate(
-            **inputs,
-            max_new_tokens=512,
-            temperature=0.7,
-            top_p=0.9,
-            do_sample=True,
-            pad_token_id=_tokenizer.eos_token_id,
-        )
-
-    new_tokens = outputs[0][inputs["input_ids"].shape[-1]:]
-    response = _tokenizer.decode(new_tokens, skip_special_tokens=True)
-    yield response.strip()
-
-
-def update_examples(model_name: str):
-    """Return example list for the selected model."""
-    return gr.update(samples=[[q] for q in MODELS[model_name]["examples"]])
+    inputs = tokenizer(input_text, return_tensors="pt").to("cpu")
+
+    # Stream generation
+    from threading import Thread
+    streamer = TextIteratorStreamer(tokenizer, skip_special_tokens=True, skip_prompt=True)
+
+    generation_kwargs = {
+        **inputs,
+        "max_new_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": 0.9,
+        "do_sample": temperature > 0,
+        "pad_token_id": tokenizer.eos_token_id,
+        "streamer": streamer,
+    }
+
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+
+    # Yield tokens as they come
+    response = rag_context
+    for new_text in streamer:
+        response += new_text
+        yield response
+
+    thread.join()
+
+
+def generate_comparison(
+    message: str,
+    use_rag: bool,
+    temperature: float,
+    max_tokens: int,
+) -> tuple[str, str, str]:
+    """Generate responses from all 3 models for comparison."""
+
+    results = {}
+    for model_name in MODELS.keys():
+        response = ""
+        for chunk in generate_response(message, [], model_name, use_rag, temperature, max_tokens):
+            response = chunk
+        results[model_name] = response
+
+    return (
+        results["ISO 27001 Expert (1.5B)"],
+        results["RGPD Expert (1.5B)"],
+        results["CyberSec Assistant (3B)"],
+    )
 
 
 # ---------------------------------------------------------------------------
 # Gradio UI
 # ---------------------------------------------------------------------------
 DESCRIPTION = """\
-## Interactive demo of three fine-tuned cybersecurity AI models
+## 🛡️ Advanced CyberSec AI Models Demo
 
-| Model | Specialty |
-|-------|-----------|
-| **ISO 27001 Expert (1.5B)** | ISO/IEC 27001 ISMS implementation and auditing |
-| **RGPD Expert (1.5B)** | GDPR / RGPD data protection regulations |
-| **CyberSec Assistant (3B)** | General cybersecurity, compliance, pentesting, SOC |
+Interactive demo with **3 fine-tuned models**, **RAG on 80+ datasets**, and **streaming responses**.
 
-Select a model from the dropdown below and start chatting.  
-*Models run on CPU — first response may take 30-60 seconds while the model loads.*
-"""
+| Model | Specialty | Size |
+|-------|-----------|------|
+| **ISO 27001 Expert** | ISO/IEC 27001 ISMS | 1.5B |
+| **RGPD Expert** | GDPR / RGPD compliance | 1.5B |
+| **CyberSec Assistant** | General cybersecurity | 3B |
 
-FOOTER = """\
-<div style="text-align:center; margin-top:1.5rem; padding-top:1rem; border-top:1px solid #444; color:#888; font-size:0.85rem;">
-  Built by <a href="https://huggingface.co/AYI-NEDJIMI" target="_blank" style="color:#6d9eeb;">AYI-NEDJIMI</a>
-  &nbsp;|&nbsp; Models fine-tuned with PEFT/LoRA on Qwen 2.5
-  &nbsp;|&nbsp; <a href="https://huggingface.co/AYI-NEDJIMI/ISO27001-Expert-1.5B" target="_blank" style="color:#6d9eeb;">ISO27001</a>
-  &nbsp;|&nbsp; <a href="https://huggingface.co/AYI-NEDJIMI/RGPD-Expert-1.5B" target="_blank" style="color:#6d9eeb;">RGPD</a>
-  &nbsp;|&nbsp; <a href="https://huggingface.co/AYI-NEDJIMI/CyberSec-Assistant-3B" target="_blank" style="color:#6d9eeb;">CyberSec-3B</a>
-</div>
+**Features:**
+- 💬 Single-model chat or compare all 3 models side-by-side
+- 🔍 RAG (Retrieval-Augmented Generation) on 80+ cybersecurity datasets
+- ⚡ Streaming responses (token-by-token)
+- 🎛️ Adjustable temperature & max tokens
 """
 
 theme = gr.themes.Soft(
@@ -219,35 +325,123 @@ theme = gr.themes.Soft(
     body_background_fill_dark="#0f1117",
     block_background_fill="#1a1c25",
     block_background_fill_dark="#1a1c25",
-    input_background_fill="#252830",
-    input_background_fill_dark="#252830",
-    button_primary_background_fill="#c0392b",
-    button_primary_background_fill_dark="#c0392b",
-    button_primary_background_fill_hover="#e74c3c",
-    button_primary_background_fill_hover_dark="#e74c3c",
 )
 
-with gr.Blocks(theme=theme, title="CyberSec AI Models Demo") as demo:
+with gr.Blocks(theme=theme, title="CyberSec AI Models - Advanced Demo") as demo:
 
-    gr.Markdown("# \U0001f6e1\ufe0f CyberSec AI Models Demo")
+    gr.Markdown("# 🛡️ CyberSec AI Models - Advanced Demo")
     gr.Markdown(DESCRIPTION)
 
-    model_selector = gr.Dropdown(
-        choices=list(MODELS.keys()),
-        value=DEFAULT_MODEL,
-        label="Select Model",
-        interactive=True,
-    )
-
-    chat = gr.ChatInterface(
-        fn=respond,
-        type="messages",
-        additional_inputs=[model_selector],
-        examples=[[q] for q in MODELS[DEFAULT_MODEL]["examples"]],
-        cache_examples=False,
-    )
-
-    gr.HTML(FOOTER)
+    with gr.Tabs() as tabs:
+
+        # Tab 1: Single Model Chat
+        with gr.Tab("💬 Chat"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    model_selector = gr.Dropdown(
+                        choices=list(MODELS.keys()),
+                        value="ISO 27001 Expert (1.5B)",
+                        label="Select Model",
+                    )
+                with gr.Column(scale=1):
+                    use_rag_chat = gr.Checkbox(
+                        label="Enable RAG",
+                        value=True,
+                        info="Retrieve context from 80+ datasets",
+                    )
+
+            with gr.Row():
+                temperature_chat = gr.Slider(0, 1, value=0.7, label="Temperature")
+                max_tokens_chat = gr.Slider(128, 1024, value=512, step=128, label="Max Tokens")
+
+            chatbot = gr.Chatbot(type="messages", height=500)
+            msg = gr.Textbox(
+                label="Your message",
+                placeholder="Ask a cybersecurity question...",
+                lines=2,
+            )
+
+            with gr.Row():
+                submit = gr.Button("Send", variant="primary")
+                clear = gr.Button("Clear")
+
+            def user(user_message, history):
+                return "", history + [{"role": "user", "content": user_message}]
+
+            def bot(history, model_name, use_rag, temp, max_tok):
+                user_message = history[-1]["content"]
+                history_context = history[:-1]
+
+                bot_message = ""
+                for chunk in generate_response(user_message, history_context, model_name, use_rag, temp, max_tok):
+                    bot_message = chunk
+                    yield history + [{"role": "assistant", "content": bot_message}]
+
+            msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+                bot, [chatbot, model_selector, use_rag_chat, temperature_chat, max_tokens_chat], chatbot
+            )
+            submit.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+                bot, [chatbot, model_selector, use_rag_chat, temperature_chat, max_tokens_chat], chatbot
+            )
+            clear.click(lambda: [], None, chatbot, queue=False)
+
+            # Examples
+            gr.Examples(
+                examples=[
+                    ["What are the key principles of ISO 27001?"],
+                    ["Explain GDPR data subject rights in detail."],
+                    ["How does the MITRE ATT&CK framework work?"],
+                    ["What are the main requirements of the NIS2 directive?"],
+                ],
+                inputs=msg,
+            )
+
+        # Tab 2: Compare Models
+        with gr.Tab("⚖️ Compare Models"):
+            gr.Markdown("### Compare responses from all 3 models side-by-side")
+
+            with gr.Row():
+                use_rag_compare = gr.Checkbox(label="Enable RAG", value=True)
+                temperature_compare = gr.Slider(0, 1, value=0.7, label="Temperature")
+                max_tokens_compare = gr.Slider(128, 1024, value=512, step=128, label="Max Tokens")
+
+            question_compare = gr.Textbox(
+                label="Question",
+                placeholder="Ask a question to all 3 models...",
+                lines=2,
+            )
+            compare_btn = gr.Button("Compare Models", variant="primary")
+
+            with gr.Row():
+                output_iso = gr.Textbox(label="ISO 27001 Expert (1.5B)", lines=15)
+                output_rgpd = gr.Textbox(label="RGPD Expert (1.5B)", lines=15)
+                output_cyber = gr.Textbox(label="CyberSec Assistant (3B)", lines=15)
+
+            compare_btn.click(
+                generate_comparison,
+                inputs=[question_compare, use_rag_compare, temperature_compare, max_tokens_compare],
+                outputs=[output_iso, output_rgpd, output_cyber],
+            )
+
+            gr.Examples(
+                examples=[
+                    ["What is a Data Protection Impact Assessment?"],
+                    ["Explain the concept of Zero Trust security."],
+                    ["What are the penalties for GDPR non-compliance?"],
+                ],
+                inputs=question_compare,
+            )
+
+    gr.HTML("""
+    <div style="text-align:center; margin-top:2rem; padding-top:1rem; border-top:1px solid #444; color:#888; font-size:0.85rem;">
+      <p>Built by <a href="https://huggingface.co/AYI-NEDJIMI" style="color:#6d9eeb;">Ayi NEDJIMI</a>
+      | Models: <a href="https://huggingface.co/AYI-NEDJIMI/ISO27001-Expert-1.5B" style="color:#6d9eeb;">ISO27001</a>,
+      <a href="https://huggingface.co/AYI-NEDJIMI/RGPD-Expert-1.5B" style="color:#6d9eeb;">RGPD</a>,
+      <a href="https://huggingface.co/AYI-NEDJIMI/CyberSec-Assistant-3B" style="color:#6d9eeb;">CyberSec-3B</a>
+      | <a href="https://huggingface.co/collections/AYI-NEDJIMI/cybersec-ai-portfolio-datasets-models-and-spaces-699224074a478ec0feeac493" style="color:#6d9eeb;">Full Portfolio</a></p>
+      <p style="font-size:0.75rem; color:#666;">Fine-tuned with QLoRA on Qwen 2.5 | RAG powered by sentence-transformers</p>
+    </div>
+    """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue().launch()

requirements.txt

@@ -3,6 +3,9 @@ transformers>=4.40.0
 peft>=0.10.0
 torch>=2.0.0
 accelerate>=0.27.0
+sentence-transformers>=2.5.0
+datasets>=2.18.0
+numpy>=1.24.0
 sentencepiece
 protobuf
-huggingface_hub
+huggingface_hub>=0.20.0