test small updated version with multiple LLMS

app.py

@@ -1,31 +1,23 @@
+#!/usr/bin/env python
+"""CVE Dashboard - Real-time vulnerability monitoring with NVD API and LLM-powered audience customization."""
+
+import os
 import json
+import time
 import logging
-import gzip
-import os
-from collections import OrderedDict
-from datetime import datetime
-from io import BytesIO
-from typing import Dict
-
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional, Tuple
 import gradio as gr
 import pandas as pd
 import plotly.express as px
+import plotly.graph_objects as go
 import requests
 
-# Configure logging for the application
+# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- Constants and Global Variables ---
-
-CURRENT_YEAR = datetime.now().year
-NVD_BASE_URL = "https://nvd.nist.gov/feeds/json/cve/1.1/nvdcve-1.1-{year}.json.gz"
-
-# In-memory LRU cache (by insertion order) to store DataFrames for recent years.
-CACHE_MAX_SIZE = 3
-DATAFRAME_CACHE: Dict[int, pd.DataFrame] = OrderedDict()
-
-# Profiles for tailoring LLM-generated summaries to different audiences
+# Audience profiles for tailored CVE descriptions
 AUDIENCE_PROFILES = {
     "Cybersecurity Professional": {
         "focus": "threat assessment, attack vectors, mitigation strategies, and security controls",
@@ -59,254 +51,762 @@ AUDIENCE_PROFILES = {
     }
 }
 
-
-# --- Data Fetching and Parsing ---
-
-def get_cve_dataframe(year: int) -> pd.DataFrame:
-    """
-    Downloads, parses, and caches the NVD feed for a specific year.
-    It returns a pandas DataFrame. Caching is used to avoid repeated downloads.
-    """
-    if year in DATAFRAME_CACHE:
-        logger.info(f"Cache hit for year {year}.")
-        DATAFRAME_CACHE.move_to_end(year) # Mark as recently used
-        return DATAFRAME_CACHE[year]
-
-    logger.info(f"Cache miss. Downloading NVD data for year {year}.")
-    url = NVD_BASE_URL.format(year=year)
-
-    try:
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-
-        with gzip.GzipFile(fileobj=BytesIO(response.content)) as f:
-            nvd_data = json.load(f)
-
-        df = parse_cve_items(nvd_data)
-
-        if len(DATAFRAME_CACHE) >= CACHE_MAX_SIZE:
-            DATAFRAME_CACHE.popitem(last=False)
-        DATAFRAME_CACHE[year] = df
-        return df
-
-    except requests.exceptions.HTTPError as e:
-        logger.error(f"HTTP Error for {year}: {e}")
-        raise gr.Error(f"Failed to download data for {year}. The feed may be unavailable.")
-    except Exception as e:
-        logger.error(f"Error processing feed for {year}: {e}")
-        raise gr.Error(f"An unexpected error occurred: {str(e)}")
-
-def parse_cve_items(nvd_data: dict) -> pd.DataFrame:
-    """
-    Extracts vulnerability details from the raw NVD JSON data into a structured DataFrame.
-    """
-    rows = []
-    for item in nvd_data.get("CVE_Items", []):
+class CVEDashboard:
+    """Main CVE Dashboard application class."""
+    
+    def __init__(self):
+        """Initialize the CVE Dashboard."""
+        self.api_key = os.getenv('NVD_API_KEY')
+        self.base_url = "https://services.nvd.nist.gov/rest/json/cves/2.0"
+        self.headers = {'apiKey': self.api_key} if self.api_key else {}
+        self.cache = {}
+        self.last_request_time = 0
+        self.rate_limit_delay = 0.7 if self.api_key else 6  # seconds between requests
+        
+        # HuggingFace token - try environment first
+        self.hf_token = os.getenv('HF_TOKEN') or os.getenv('HUGGINGFACE_TOKEN')
+        
+    def _rate_limit(self):
+        """Implement rate limiting for NVD API."""
+        current_time = time.time()
+        time_since_last = current_time - self.last_request_time
+        if time_since_last < self.rate_limit_delay:
+            time.sleep(self.rate_limit_delay - time_since_last)
+        self.last_request_time = time.time()
+    
+    def fetch_cves(self, 
+                   days_back: int = 7,
+                   keyword: Optional[str] = None,
+                   severity: Optional[str] = None,
+                   results_per_page: int = 50) -> Tuple[List[Dict], str]:
+        """
+        Fetch CVEs from NVD API.
+        
+        Args:
+            days_back: Number of days to look back
+            keyword: Optional keyword to search
+            severity: Optional severity filter (LOW, MEDIUM, HIGH, CRITICAL)
+            results_per_page: Number of results per page (max 2000)
+            
+        Returns:
+            Tuple of (list of CVEs, status message)
+        """
         try:
-            cve_id = item.get("cve", {}).get("CVE_data_meta", {}).get("ID", "N/A")
-            desc_data = item.get("cve", {}).get("description", {}).get("description_data", [])
-            description = desc_data[0].get("value", "No description") if desc_data else "No description"
-            published = item.get("publishedDate", "")
-            base_score, severity, attack_vector = None, "N/A", "N/A"
-
-            if "baseMetricV3" in item.get("impact", {}):
-                impact_v3 = item["impact"]["baseMetricV3"]["cvssV3"]
-                base_score = impact_v3.get("baseScore")
-                severity = impact_v3.get("baseSeverity")
-                attack_vector = impact_v3.get("attackVector")
-            elif "baseMetricV2" in item.get("impact", {}):
-                impact_v2 = item["impact"]["baseMetricV2"]
-                base_score = impact_v2["cvssV2"].get("baseScore")
-                severity = impact_v2.get("severity")
-                attack_vector = impact_v2.get("accessVector")
-
-            problem_types = item.get("cve", {}).get("problemtype", {}).get("problemtype_data", [])
-            cwe_ids = [desc["value"] for pt in problem_types for desc in pt.get("description", []) if desc.get("value", "").startswith("CWE-")]
+            self._rate_limit()
+            
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=days_back)
             
-            rows.append({
-                "CVE_ID": cve_id, "Description": description, "Published": published[:10],
-                "Base_Score": base_score, "Severity": severity, "Attack_Vector": attack_vector,
-                "CWE_IDs": ", ".join(cwe_ids) if cwe_ids else "N/A"
-            })
+            params = {
+                'pubStartDate': start_date.strftime('%Y-%m-%dT00:00:00.000'),
+                'pubEndDate': end_date.strftime('%Y-%m-%dT23:59:59.999'),
+                'resultsPerPage': min(results_per_page, 2000)
+            }
+            
+            if keyword:
+                params['keywordSearch'] = keyword
+                
+            response = requests.get(
+                self.base_url,
+                headers=self.headers,
+                params=params,
+                timeout=30
+            )
+            response.raise_for_status()
+            
+            data = response.json()
+            vulnerabilities = data.get('vulnerabilities', [])
+            
+            # Process and filter CVEs
+            processed_cves = []
+            for vuln in vulnerabilities:
+                cve = self._process_cve(vuln.get('cve', {}))
+                if severity and cve['severity'] != severity:
+                    continue
+                processed_cves.append(cve)
+            
+            status = f"✓ Fetched {len(processed_cves)} CVEs from the last {days_back} days"
+            if keyword:
+                status += f" matching '{keyword}'"
+            if severity:
+                status += f" with {severity} severity"
+                
+            return processed_cves, status
+            
+        except requests.exceptions.RequestException as e:
+            return [], f"✗ API Error: {str(e)}"
         except Exception as e:
-            cve_id_str = cve_id if 'cve_id' in locals() else "Unknown"
-            logger.warning(f"Skipping malformed CVE item ({cve_id_str}): {e}")
-            continue
-
-    df = pd.DataFrame(rows)
-    if "Base_Score" in df.columns:
-        df["Base_Score"] = pd.to_numeric(df["Base_Score"], errors='coerce')
-    return df
-
-
-# --- LLM Integration ---
+            return [], f"✗ Error: {str(e)}"
+    
+    def _process_cve(self, cve_data: Dict) -> Dict:
+        """Process raw CVE data into a structured format."""
+        cve_id = cve_data.get('id', 'Unknown')
+        
+        # Extract description
+        descriptions = cve_data.get('descriptions', [])
+        description = next(
+            (d['value'] for d in descriptions if d.get('lang') == 'en'),
+            'No description available'
+        )
+        
+        # Extract CVSS metrics and severity
+        metrics = cve_data.get('metrics', {})
+        cvss_data = {}
+        severity = 'UNKNOWN'
+        score = 0.0
+        
+        # Try CVSS 3.1 first, then 3.0, then 2.0
+        for cvss_version in ['cvssMetricV31', 'cvssMetricV30', 'cvssMetricV2']:
+            if cvss_version in metrics and metrics[cvss_version]:
+                metric = metrics[cvss_version][0]
+                cvss_data = metric.get('cvssData', {})
+                score = cvss_data.get('baseScore', 0.0)
+                severity = cvss_data.get('baseSeverity', 'UNKNOWN')
+                break
+        
+        # Extract references
+        references = cve_data.get('references', [])
+        ref_urls = [ref.get('url', '') for ref in references[:5]]  # Limit to 5 refs
+        
+        # Extract dates
+        published = cve_data.get('published', '')
+        modified = cve_data.get('lastModified', '')
+        
+        return {
+            'id': cve_id,
+            'description': description,  # Keep full description for LLM processing
+            'display_description': description[:500] + '...' if len(description) > 500 else description,
+            'severity': severity,
+            'score': score,
+            'published': published[:10] if published else 'Unknown',
+            'modified': modified[:10] if modified else 'Unknown',
+            'references': ref_urls,
+            'cvss_version': cvss_data.get('version', 'Unknown'),
+            'vector_string': cvss_data.get('vectorString', 'N/A')
+        }
+    
+    def create_severity_chart(self, cves: List[Dict]) -> go.Figure:
+        """Create a pie chart of CVE severities."""
+        if not cves:
+            fig = go.Figure()
+            fig.add_annotation(text="No data available", 
+                             xref="paper", yref="paper",
+                             x=0.5, y=0.5, showarrow=False)
+            return fig
+        
+        severity_counts = pd.DataFrame(cves)['severity'].value_counts()
+        
+        colors = {
+            'CRITICAL': '#d32f2f',
+            'HIGH': '#f57c00',
+            'MEDIUM': '#fbc02d',
+            'LOW': '#388e3c',
+            'UNKNOWN': '#9e9e9e'
+        }
+        
+        fig = px.pie(
+            values=severity_counts.values,
+            names=severity_counts.index,
+            title="CVE Distribution by Severity",
+            color=severity_counts.index,
+            color_discrete_map=colors
+        )
+        
+        fig.update_traces(textposition='inside', textinfo='percent+label')
+        fig.update_layout(height=400)
+        
+        return fig
+    
+    def create_timeline_chart(self, cves: List[Dict]) -> go.Figure:
+        """Create a timeline chart of CVE publications."""
+        if not cves:
+            fig = go.Figure()
+            fig.add_annotation(text="No data available", 
+                             xref="paper", yref="paper",
+                             x=0.5, y=0.5, showarrow=False)
+            return fig
+        
+        df = pd.DataFrame(cves)
+        df['published'] = pd.to_datetime(df['published'])
+        
+        # Group by date and severity
+        timeline_data = df.groupby([df['published'].dt.date, 'severity']).size().reset_index(name='count')
+        
+        fig = px.bar(
+            timeline_data,
+            x='published',
+            y='count',
+            color='severity',
+            title="CVE Publications Timeline",
+            color_discrete_map={
+                'CRITICAL': '#d32f2f',
+                'HIGH': '#f57c00',
+                'MEDIUM': '#fbc02d',
+                'LOW': '#388e3c',
+                'UNKNOWN': '#9e9e9e'
+            }
+        )
+        
+        fig.update_layout(
+            xaxis_title="Publication Date",
+            yaxis_title="Number of CVEs",
+            height=400,
+            hovermode='x unified'
+        )
+        
+        return fig
+    
+    def create_score_distribution(self, cves: List[Dict]) -> go.Figure:
+        """Create a histogram of CVSS scores."""
+        if not cves:
+            fig = go.Figure()
+            fig.add_annotation(text="No data available", 
+                             xref="paper", yref="paper",
+                             x=0.5, y=0.5, showarrow=False)
+            return fig
+        
+        scores = [cve['score'] for cve in cves if cve['score'] > 0]
+        
+        fig = go.Figure(data=[go.Histogram(
+            x=scores,
+            nbinsx=20,
+            marker_color='#1976d2'
+        )])
+        
+        fig.update_layout(
+            title="CVSS Score Distribution",
+            xaxis_title="CVSS Score",
+            yaxis_title="Count",
+            height=400,
+            showlegend=False
+        )
+        
+        # Add severity range annotations
+        fig.add_vrect(x0=0, x1=3.9, fillcolor="green", opacity=0.1, annotation_text="Low")
+        fig.add_vrect(x0=4, x1=6.9, fillcolor="yellow", opacity=0.1, annotation_text="Medium")
+        fig.add_vrect(x0=7, x1=8.9, fillcolor="orange", opacity=0.1, annotation_text="High")
+        fig.add_vrect(x0=9, x1=10, fillcolor="red", opacity=0.1, annotation_text="Critical")
+        
+        return fig
+    
+    def format_cve_table(self, cves: List[Dict]) -> pd.DataFrame:
+        """Format CVEs for display in a table."""
+        if not cves:
+            return pd.DataFrame()
+        
+        df = pd.DataFrame(cves)
+        
+        # Select and reorder columns
+        columns = ['id', 'severity', 'score', 'published', 'display_description']
+        df = df[columns]
+        
+        # Format the dataframe
+        df = df.rename(columns={
+            'id': 'CVE ID',
+            'severity': 'Severity',
+            'score': 'CVSS Score',
+            'published': 'Published',
+            'display_description': 'Description'
+        })
+        
+        return df
+    
+    def export_to_json(self, cves: List[Dict]) -> str:
+        """Export CVEs to JSON format."""
+        if not cves:
+            return "No data to export"
+        
+        filename = f"cve_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        with open(filename, 'w') as f:
+            json.dump(cves, f, indent=2)
+        
+        return f"✓ Exported {len(cves)} CVEs to {filename}"
+    
+    def export_to_csv(self, cves: List[Dict]) -> str:
+        """Export CVEs to CSV format."""
+        if not cves:
+            return "No data to export"
+        
+        df = self.format_cve_table(cves)
+        filename = f"cve_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        df.to_csv(filename, index=False)
+        
+        return f"✓ Exported {len(cves)} CVEs to {filename}"
 
-def generate_tailored_summary(cve_description: str, audience: str, hf_token: str) -> str:
+def generate_tailored_summary(cve_description: str, audience: str, hf_token: Optional[str] = None, max_retries: int = 2) -> str:
     """
-    Generates a tailored CVE summary using the Hugging Face Inference API.
+    Generates a tailored CVE summary using Apertus via HuggingFace Inference API.
+    
+    Args:
+        cve_description: The original CVE description
+        audience: Target audience from AUDIENCE_PROFILES
+        hf_token: HuggingFace API token (optional if set as env var)
+        max_retries: Maximum number of retry attempts
+    
+    Returns:
+        Tailored summary or error message
     """
-    if not hf_token:
-        raise gr.Error("Hugging Face API token is not configured as a Space Secret.")
+    # Use provided token or fall back to environment variable
+    token = hf_token or os.getenv('HF_TOKEN') or os.getenv('HUGGINGFACE_TOKEN')
+    
+    if not token:
+        return "❌ HuggingFace API token is required. Please set HF_TOKEN environment variable or enter your token."
+    
     if not cve_description or not audience:
-        return "Please select a CVE and an audience first."
-
-    api_url = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"
-    headers = {"Authorization": f"Bearer {hf_token}"}
-    profile = AUDIENCE_PROFILES.get(audience, {})
+        return "❌ Please select a CVE and an audience first."
     
-    prompt = f"""<s>[INST] You are an expert cybersecurity analyst. Your task is to rewrite the following technical CVE description into a concise, actionable summary for a specific professional audience.
-
-    **Target Audience:** {audience}
-    - **Focus:** {profile.get('focus', 'N/A')}
-    - **Key Priorities:** {', '.join(profile.get('priorities', []))}
-
-    **Original CVE Description:**
-    ---
-    {cve_description}
-    ---
-
-    Rewrite the description in a {profile.get('tone', 'professional')} tone, focusing on what matters most to this audience. Do not start with "As a [role]...". Directly provide the summary. [/INST]"""
-
-    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 256, "return_full_text": False}}
-
-    try:
-        response = requests.post(api_url, headers=headers, json=payload, timeout=45)
-        if response.status_code != 200:
-            error_message = response.json().get("error", "Unknown error")
-            logger.error(f"Inference API Error: {error_message}")
-            return f"Error from API: {error_message}. The model might be loading, please try again."
-        
-        return response.json()[0]['generated_text'].strip()
-
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Request to Inference API failed: {e}")
-        return f"Error: Could not connect to the Hugging Face API. {e}"
-
-
-# --- Analysis and Visualization ---
-
-def analyze_and_visualize(df: pd.DataFrame, severity: str, vector: str, search: str):
-    """
-    Filters the main DataFrame and generates all outputs: a filtered table,
-    visualizations, and a summary markdown string.
-    """
-    if df is None or df.empty:
-        return pd.DataFrame(), None, None, "### No Data Loaded"
-
-    filtered_df = df.copy()
-    if severity != "All":
-        filtered_df = filtered_df[filtered_df["Severity"] == severity]
-    if vector != "All":
-        filtered_df = filtered_df[filtered_df["Attack_Vector"] == vector]
-    if search:
-        mask = (filtered_df["CVE_ID"].str.contains(search, case=False, na=False) |
-                filtered_df["Description"].str.contains(search, case=False, na=False) |
-                filtered_df["CWE_IDs"].str.contains(search, case=False, na=False))
-        filtered_df = filtered_df[mask]
-
-    return filtered_df, create_severity_chart(filtered_df), create_timeline_chart(filtered_df), create_summary_text(filtered_df)
-
-def create_severity_chart(df: pd.DataFrame):
-    """Creates a bar chart for CVE severity distribution."""
-    if df.empty: return None
-    order = ["CRITICAL", "HIGH", "MEDIUM", "LOW", "N/A"]
-    counts = df["Severity"].value_counts().reindex(order, fill_value=0)
-    color_map = {"CRITICAL": "#8B0000", "HIGH": "#FF4500", "MEDIUM": "#FFA500", "LOW": "#FFD700", "N/A": "#D3D3D3"}
-
-    fig = px.bar(counts, x=counts.index, y=counts.values, labels={"x": "Severity", "y": "Count"},
-                 title="CVE Severity Distribution", color=counts.index, color_discrete_map=color_map, text_auto=True)
-    fig.update_layout(showlegend=False, xaxis={'categoryorder':'array', 'categoryarray':order})
-    return fig
-
-def create_timeline_chart(df: pd.DataFrame):
-    """Creates a line chart showing CVE publications over time."""
-    if df.empty or 'Published' not in df.columns: return None
-    df_copy = df.copy()
-    df_copy["Date"] = pd.to_datetime(df_copy["Published"], errors='coerce')
-    df_copy.dropna(subset=["Date"], inplace=True)
-    if df_copy.empty: return None
-
-    counts = df_copy.set_index("Date").resample('M').size()
-    fig = px.line(x=counts.index, y=counts.values, labels={"x": "Month", "y": "Number of CVEs"},
-                  title="CVE Publications Timeline", markers=True)
-    return fig
-
-def create_summary_text(df: pd.DataFrame) -> str:
-    """Generates a markdown string with key statistics from the DataFrame."""
-    if df.empty: return "### No results match your filter criteria."
-    scores = df['Base_Score'].dropna()
-    avg_score = f"{scores.mean():.2f}" if not scores.empty else 'N/A'
-    return f"""### Summary Statistics
-- **Total CVEs Found:** {len(df):,}
-- **Critical:** {len(df[df['Severity'] == 'CRITICAL']):,}
-- **High:** {len(df[df['Severity'] == 'HIGH']):,}
-- **Average Base Score:** {avg_score}"""
-
-
-# --- Gradio UI and Event Logic ---
-
-def create_dashboard():
-    """Builds the entire Gradio interface and defines event handling."""
-    with gr.Blocks(theme=gr.themes.Soft(), title="CVE Dashboard") as dashboard:
-        df_state = gr.State()
-        selected_cve_description = gr.State("")
-        hf_token_state = gr.State(os.environ.get("HF_TOKEN"))
+    if audience not in AUDIENCE_PROFILES:
+        return f"❌ Unknown audience: {audience}"
+    
+    # Try Apertus models with fallback options
+    models = [
+        "swiss-ai/Apertus-8B-Instruct-2509",  # Primary choice - smaller, faster
+        "mistralai/Mistral-7B-Instruct-v0.3"  # Fallback to original
+    ]
+    
+    headers = {"Authorization": f"Bearer {token}"}
+    profile = AUDIENCE_PROFILES[audience]
+    
+    # Apertus uses chat template format
+    messages = [
+        {
+            "role": "user", 
+            "content": f"""You are an expert cybersecurity analyst. Rewrite this CVE description for a {audience}.
+
+**Target Audience:** {audience}
+**Focus:** {profile['focus']}
+**Tone:** {profile['tone']}
+**Key Priorities:** {', '.join(profile['priorities'])}
+
+**CVE Description:**
+{cve_description[:1200]}
+
+Provide a concise, actionable summary (2-3 sentences) highlighting what matters most to this audience. Focus on practical implications and next steps."""
+        }
+    ]
+    
+    for model in models:
+        api_url = f"https://api-inference.huggingface.co/models/{model}"
+        
+        # Different payload structure for Apertus vs Mistral
+        if "Apertus" in model:
+            payload = {
+                "inputs": {
+                    "messages": messages,
+                    "max_tokens": 200,
+                    "temperature": 0.8,  # Recommended by Apertus docs
+                    "top_p": 0.9        # Recommended by Apertus docs
+                }
+            }
+        else:
+            # Fallback to Mistral format
+            prompt = f"""<s>[INST] You are an expert cybersecurity analyst. Rewrite the following CVE description for a {audience}.
+
+**Focus:** {profile['focus']}
+**Tone:** {profile['tone']}
+
+CVE: {cve_description[:1000]}
+
+Provide a 2-3 sentence summary highlighting what matters most to this audience: [/INST]"""
+            
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": 150,
+                    "temperature": 0.5,
+                    "top_p": 0.9,
+                    "do_sample": True,
+                    "return_full_text": False,
+                    "stop": ["\n\n"]
+                }
+            }
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Generating summary with {model} (attempt {attempt + 1})")
+                
+                response = requests.post(api_url, headers=headers, json=payload, timeout=45)
+                
+                if response.status_code == 200:
+                    try:
+                        result = response.json()
+                        
+                        # Handle different response formats
+                        summary = ""
+                        if "Apertus" in model:
+                            # Apertus response format
+                            if isinstance(result, list) and len(result) > 0:
+                                if "generated_text" in result[0]:
+                                    summary = result[0]["generated_text"]
+                                elif "choices" in result[0] and len(result[0]["choices"]) > 0:
+                                    summary = result[0]["choices"][0].get("message", {}).get("content", "")
+                        else:
+                            # Mistral response format
+                            if isinstance(result, list) and len(result) > 0:
+                                summary = result[0].get('generated_text', '').strip()
+                        
+                        if summary and len(summary) > 20:
+                            logger.info(f"Successfully generated summary with {model}")
+                            return f"**{audience} Summary (via {model.split('/')[-1]}):**\n\n{summary}"
+                            
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"JSON decode error with {model}: {e}")
+                        continue
+                
+                elif response.status_code == 503:
+                    logger.warning(f"Model {model} is loading, trying next model...")
+                    break  # Try next model
+                
+                elif response.status_code == 429:
+                    if attempt < max_retries - 1:
+                        time.sleep(5)
+                        continue
+                    else:
+                        break
+                
+                else:
+                    logger.warning(f"HTTP {response.status_code} with {model}")
+                    break
+                        
+            except requests.exceptions.Timeout:
+                logger.warning(f"Timeout with {model}, trying next model...")
+                break
+            
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Request failed with {model}: {e}")
+                break
+            
+            except Exception as e:
+                logger.error(f"Unexpected error with {model}: {e}")
+                break
+    
+    return "⏳ AI models are currently busy. This can happen during peak usage. Please try again in a few minutes."
 
-        gr.Markdown("# CVE Dashboard: NVD Feed Analyzer")
-        gr.Markdown("Explore CVE data from the National Vulnerability Database. **Note:** This demo uses deprecated NVD JSON feeds; a production app should use the NVD API 2.0.")
+def create_interface():
+    """Create the Gradio interface."""
+    dashboard = CVEDashboard()
+    
+    # Check if HF token is available in environment
+    has_env_token = bool(dashboard.hf_token)
+    
+    with gr.Blocks(title="CVE Dashboard", theme=gr.themes.Soft()) as interface:
+        # State to store fetched CVEs
+        cve_state = gr.State([])
+        
+        gr.Markdown(
+            """
+            # 🛡️ CVE Dashboard with AI-Powered Audience Customization
+            Real-time vulnerability monitoring using NIST National Vulnerability Database (NVD) with LLM-powered audience-specific summaries
+            """
+        )
         
         with gr.Row():
             with gr.Column(scale=1):
-                year_dd = gr.Dropdown(choices=list(range(2002, CURRENT_YEAR + 1))[::-1], value=CURRENT_YEAR - 1, label="1. Select Year")
-                severity_dd = gr.Dropdown(choices=["All", "CRITICAL", "HIGH", "MEDIUM", "LOW"], value="All", label="2. Filter by Severity")
-                vector_dd = gr.Dropdown(choices=["All", "NETWORK", "ADJACENT_NETWORK", "LOCAL", "PHYSICAL"], value="All", label="3. Filter by Attack Vector")
-                search_tb = gr.Textbox(label="4. Search Keyword", placeholder="e.g., 'Log4j', 'CWE-79', ...")
-                filter_btn = gr.Button("Apply Filters", variant="primary")
-
+                # Only show token input if not available in environment
+                if not has_env_token:
+                    gr.Markdown("### 🔧 Configuration")
+                    hf_token = gr.Textbox(
+                        label="HuggingFace API Token",
+                        placeholder="hf_...",
+                        type="password",
+                        info="Required for AI summaries. Get yours at https://huggingface.co/settings/tokens"
+                    )
+                else:
+                    gr.Markdown("### ✅ AI Ready")
+                    gr.Markdown("HuggingFace token configured via environment variable")
+                    hf_token = gr.State(dashboard.hf_token)  # Hidden state
+                
+                gr.Markdown("### 🔍 Search Parameters")
+                
+                days_back = gr.Slider(
+                    minimum=1,
+                    maximum=30,
+                    value=7,
+                    step=1,
+                    label="Days to Look Back"
+                )
+                
+                keyword = gr.Textbox(
+                    label="Keyword Search (Optional)",
+                    placeholder="e.g., Apache, Linux, Microsoft"
+                )
+                
+                severity_filter = gr.Dropdown(
+                    choices=[None, "CRITICAL", "HIGH", "MEDIUM", "LOW"],
+                    label="Severity Filter",
+                    value=None
+                )
+                
+                fetch_btn = gr.Button("🔍 Fetch CVEs", variant="primary")
+                
+                gr.Markdown("### 📤 Export Options")
+                export_json_btn = gr.Button("📄 Export to JSON")
+                export_csv_btn = gr.Button("📊 Export to CSV")
+                export_status = gr.Textbox(label="Export Status", interactive=False)
+                
             with gr.Column(scale=3):
-                summary_out = gr.Markdown()
+                status_text = gr.Textbox(label="Status", interactive=False)
+                
                 with gr.Tabs():
-                    with gr.TabItem("📊 Data Table"):
-                        table_out = gr.DataFrame(headers=["CVE_ID", "Severity", "Base_Score", "Description"], wrap=True, row_count=15, interactive=True)
-                    with gr.TabItem("📈 Severity Chart"):
-                        plot_severity_out = gr.Plot()
-                    with gr.TabItem("📉 Timeline Chart"):
-                        plot_timeline_out = gr.Plot()
+                    with gr.Tab("📊 Overview"):
+                        with gr.Row():
+                            severity_chart = gr.Plot(label="Severity Distribution")
+                            timeline_chart = gr.Plot(label="Timeline")
+                        score_chart = gr.Plot(label="CVSS Score Distribution")
+                    
+                    with gr.Tab("📋 CVE List"):
+                        cve_table = gr.DataFrame(
+                            label="CVE Details",
+                            wrap=True,
+                            row_count=15
+                        )
+                    
+                    with gr.Tab("🤖 AI-Powered Summaries"):
+                        gr.Markdown("### Generate Audience-Specific CVE Summaries")
+                        
+                        if not has_env_token:
+                            gr.Markdown("⚠️ **Note:** Enter your HuggingFace token in the Configuration section first")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                cve_selector = gr.Dropdown(
+                                    label="Select CVE",
+                                    choices=[],
+                                    info="Choose a CVE from the fetched results"
+                                )
+                                
+                                audience_selector = gr.Dropdown(
+                                    label="Target Audience",
+                                    choices=list(AUDIENCE_PROFILES.keys()),
+                                    value="Cybersecurity Professional",
+                                    info="Select the professional perspective"
+                                )
+                                
+                                generate_btn = gr.Button("🧠 Generate AI Summary", variant="primary")
+                                
+                                # Add status for generation
+                                generation_status = gr.Textbox(
+                                    label="Generation Status",
+                                    value="Ready to generate summaries",
+                                    interactive=False
+                                )
+                            
+                            with gr.Column():
+                                audience_info = gr.Markdown(
+                                    value="**Focus:** threat assessment, attack vectors, mitigation strategies, and security controls\n\n**Priorities:** exploitation methods, defensive measures, risk assessment, compliance implications"
+                                )
+                        
+                        original_description = gr.Textbox(
+                            label="Original CVE Description",
+                            lines=4,
+                            interactive=False
+                        )
+                        
+                        tailored_summary = gr.Textbox(
+                            label="AI-Generated Summary",
+                            lines=6,
+                            interactive=False,
+                            placeholder="Select a CVE and audience, then click 'Generate AI Summary'"
+                        )
+                    
+                    with gr.Tab("ℹ️ About"):
+                        gr.Markdown(
+                            """
+                            ### About this Dashboard
+                            
+                            This dashboard provides real-time monitoring of Common Vulnerabilities and Exposures (CVEs) 
+                            from the NIST National Vulnerability Database with AI-powered audience customization.
+                            
+                            **Features:**
+                            - Search CVEs by date range and keywords
+                            - Filter by severity levels
+                            - Visualize CVE distributions and trends
+                            - Export data to JSON or CSV formats
+                            - **NEW:** AI-powered audience-specific summaries using multiple LLMs
+                            
+                            **Supported Audiences:**
+                            - **Cybersecurity Professional:** Focus on threats, attack vectors, and mitigation
+                            - **Data Scientist:** Emphasis on data risks and model vulnerabilities  
+                            - **Data Engineer:** Infrastructure security and pipeline risks
+                            - **Full-Stack Developer:** Code vulnerabilities and implementation fixes
+                            - **Product Owner:** Business impact and prioritization guidance
+                            - **Manager:** Executive summary with business implications
+                            
+                            **Data Source:** [NIST NVD API](https://nvd.nist.gov/developers/vulnerabilities)
+                            
+                            **AI Models:** Multiple HuggingFace models with fallback support
+                            
+                            **Performance Optimizations:**
+                            - Shorter timeouts for faster failure detection
+                            - Multiple model fallback for reliability
+                            - Optimized prompts for quicker responses
+                            
+                            **Rate Limits:**
+                            - NVD API: 5 requests/30s (without key), 50 requests/30s (with key)
+                            - HuggingFace API: Varies by plan, includes cold start delays
+                            
+                            **Severity Levels:**
+                            - **CRITICAL** (9.0-10.0): Complete system compromise possible
+                            - **HIGH** (7.0-8.9): Significant impact, immediate patching recommended
+                            - **MEDIUM** (4.0-6.9): Moderate impact, plan for updates
+                            - **LOW** (0.1-3.9): Minor impact, update in regular cycle
+                            """
+                        )
+        
+        # Event handlers
+        def fetch_and_display(days, keyword_search, severity):
+            """Fetch CVEs and update all displays."""
+            cves, status = dashboard.fetch_cves(
+                days_back=days,
+                keyword=keyword_search if keyword_search else None,
+                severity=severity if severity else None
+            )
+            
+            if cves:
+                df = dashboard.format_cve_table(cves)
+                severity_fig = dashboard.create_severity_chart(cves)
+                timeline_fig = dashboard.create_timeline_chart(cves)
+                score_fig = dashboard.create_score_distribution(cves)
                 
-                with gr.Accordion("Tailored CVE Analysis (Select a row in the table above)", open=False) as llm_accordion:
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            original_desc_out = gr.Textbox(label="Full Original CVE Description", lines=8, interactive=False)
-                        with gr.Column(scale=1):
-                            audience_dd = gr.Dropdown(choices=list(AUDIENCE_PROFILES.keys()), label="Select Audience", value="Cybersecurity Professional")
-                            generate_btn = gr.Button("Generate Tailored Summary", variant="primary")
-                    summary_llm_out = gr.Markdown("*Your tailored summary will appear here...*")
-
-        # --- Event Handling Logic ---
-        def on_year_change(year):
-            df = get_cve_dataframe(year)
-            return df, *analyze_and_visualize(df, "All", "All", "")
-
-        def on_select_cve(df: pd.DataFrame, evt: gr.SelectData):
-            if evt.value is None: return "", "", gr.update(visible=False)
-            full_description = df.iloc[evt.index[0]]["Description"]
-            return full_description, full_description, gr.update(visible=True)
-
-        filter_inputs = [df_state, severity_dd, vector_dd, search_tb]
-        analysis_outputs = [table_out, plot_severity_out, plot_timeline_out, summary_out]
+                # Update CVE selector choices
+                cve_choices = [f"{cve['id']} ({cve['severity']}, {cve['score']})" for cve in cves]
+                
+                return (
+                    cves,  # Update state
+                    status,
+                    df,
+                    severity_fig,
+                    timeline_fig,
+                    score_fig,
+                    gr.Dropdown(choices=cve_choices, value=cve_choices[0] if cve_choices else None)  # Update CVE selector
+                )
+            else:
+                empty_fig = go.Figure()
+                empty_fig.add_annotation(
+                    text="No data available",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False
+                )
+                
+                return (
+                    [],  # Update state
+                    status,
+                    pd.DataFrame(),
+                    empty_fig,
+                    empty_fig,
+                    empty_fig,
+                    gr.Dropdown(choices=[], value=None)  # Clear CVE selector
+                )
         
-        year_dd.change(fn=on_year_change, inputs=[year_dd], outputs=[df_state] + analysis_outputs)
-        dashboard.load(fn=on_year_change, inputs=[year_dd], outputs=[df_state] + analysis_outputs)
-
-        for control in [severity_dd, vector_dd, filter_btn, search_tb]:
-            event = control.click if isinstance(control, gr.Button) else (control.submit if isinstance(control, gr.Textbox) else control.change)
-            event(fn=analyze_and_visualize, inputs=filter_inputs, outputs=analysis_outputs)
-
-        table_out.select(fn=on_select_cve, inputs=[df_state], outputs=[selected_cve_description, original_desc_out, llm_accordion], show_progress="hidden")
-        generate_btn.click(fn=generate_tailored_summary, inputs=[selected_cve_description, audience_dd, hf_token_state], outputs=[summary_llm_out])
-
-    return dashboard
+        def update_audience_info(audience):
+            """Update audience information display."""
+            if audience in AUDIENCE_PROFILES:
+                profile = AUDIENCE_PROFILES[audience]
+                info = f"**Focus:** {profile['focus']}\n\n**Priorities:** {', '.join(profile['priorities'])}"
+                return info
+            return "Select an audience to see details"
+        
+        def update_cve_description(selected_cve, cves):
+            """Update the original CVE description when a CVE is selected."""
+            if not selected_cve or not cves:
+                return ""
+            
+            # Extract CVE ID from the selection (format: "CVE-2024-1234 (HIGH, 7.5)")
+            cve_id = selected_cve.split(" (")[0]
+            
+            # Find the matching CVE
+            for cve in cves:
+                if cve['id'] == cve_id:
+                    return cve['description']
+            
+            return "CVE description not found"
+        
+        def generate_summary_with_status(selected_cve, audience, token, cves):
+            """Generate audience-specific summary with status updates."""
+            if not selected_cve or not audience or not cves:
+                return "Please select a CVE and audience first.", "❌ Missing selection"
+            
+            # Extract CVE ID from the selection
+            cve_id = selected_cve.split(" (")[0]
+            
+            # Find the matching CVE
+            for cve in cves:
+                if cve['id'] == cve_id:
+                    # Update status to show generation in progress
+                    yield "Generating AI summary... This may take 30-60 seconds.", "🔄 Generating..."
+                    
+                    summary = generate_tailored_summary(cve['description'], audience, token)
+                    
+                    if summary.startswith("❌"):
+                        yield summary, "❌ Generation failed"
+                    elif summary.startswith("⏳"):
+                        yield summary, "⏳ Models busy"
+                    else:
+                        yield summary, "✅ Summary generated"
+                    return
+            
+            yield "CVE not found", "❌ CVE not found"
+        
+        # Wire up the event handlers
+        fetch_btn.click(
+            fn=fetch_and_display,
+            inputs=[days_back, keyword, severity_filter],
+            outputs=[cve_state, status_text, cve_table, severity_chart, timeline_chart, score_chart, cve_selector]
+        )
+        
+        audience_selector.change(
+            fn=update_audience_info,
+            inputs=[audience_selector],
+            outputs=[audience_info]
+        )
+        
+        cve_selector.change(
+            fn=update_cve_description,
+            inputs=[cve_selector, cve_state],
+            outputs=[original_description]
+        )
+        
+        generate_btn.click(
+            fn=generate_summary_with_status,
+            inputs=[cve_selector, audience_selector, hf_token, cve_state],
+            outputs=[tailored_summary, generation_status]
+        )
+        
+        export_json_btn.click(
+            fn=lambda cves: dashboard.export_to_json(cves),
+            inputs=[cve_state],
+            outputs=[export_status]
+        )
+        
+        export_csv_btn.click(
+            fn=lambda cves: dashboard.export_to_csv(cves),
+            inputs=[cve_state],
+            outputs=[export_status]
+        )
+        
+        # Load initial data
+        interface.load(
+            fn=fetch_and_display,
+            inputs=[days_back, keyword, severity_filter],
+            outputs=[cve_state, status_text, cve_table, severity_chart, timeline_chart, score_chart, cve_selector]
+        )
+    
+    return interface
 
 if __name__ == "__main__":
-    cve_dashboard = create_dashboard()
-    cve_dashboard.launch()
+    # Check for API keys
+    if os.getenv('NVD_API_KEY'):
+        print("✓ NVD API key loaded - Higher rate limits enabled")
+    else:
+        print("⚠ No NVD API key found - Using lower rate limits")
+        print("  Get a free API key at: https://nvd.nist.gov/developers/request-an-api-key")
+    
+    if os.getenv('HF_TOKEN') or os.getenv('HUGGINGFACE_TOKEN'):
+        print("✓ HuggingFace token loaded - AI summaries enabled")
+    else:
+        print("⚠ No HuggingFace token found - Users will need to enter their own")
+        print("  Get a free token at: https://huggingface.co/settings/tokens")
+    
+    # Create and launch the interface
+    app = create_interface()
+    app.launch()