Datasets:

DuyTa
/

cve-kgrag-db

#!/usr/bin/env python3
"""
Hugging Face Inference Engine for CVE Cybersecurity LLM
Uses Llama 3.1 8B model for CVE analysis and security recommendations.
Supports both base model and fine-tuned models.
"""

import json
import logging
import time
import os
from pathlib import Path
from typing import Dict, List, Any, Optional
import sys

# Add project root to path
project_root = Path(__file__).parent.parent.parent
sys.path.insert(0, str(project_root))

from config import Config

# Import transformers
try:
    from transformers import AutoTokenizer, AutoModelForCausalLM
    from peft import PeftModel, PeftConfig
    import torch
    from torch.nn import functional as F
    from huggingface_hub import login
except ImportError as e:
    print(f"Error importing transformers: {e}")
    print("Please install: pip install transformers torch accelerate peft")
    sys.exit(1)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class HFCVEInferenceEngine:
    """Hugging Face inference engine for CVE cybersecurity analysis"""
    
    def __init__(self, model_name: str = "meta-llama/Meta-Llama-3-8B", use_fine_tuned: bool = False, fine_tuned_path: str = "models/fine_tuned_cve_production"):
        self.config = Config()
        self.model_name = model_name
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.use_fine_tuned = use_fine_tuned
        self.fine_tuned_path = Path(fine_tuned_path)
        
        # Load and authenticate with token
        self.token = self._load_token()
        self._authenticate()
        
        # Initialize model and tokenizer
        self.tokenizer = None
        self.model = None
        
        # System prompts for different analysis types
        self.system_prompts = {
            'vulnerability_analysis': """You are a cybersecurity expert. Analyze the CVE and provide:
- Severity assessment (Critical/High/Medium/Low)
- Key technical details
- Impact analysis
- Brief remediation steps

Keep responses concise and actionable.""",
            
            'remediation': """You are a cybersecurity specialist. Provide specific remediation steps:
- Immediate actions
- Patch information
- Workarounds
- Verification steps

Focus on practical solutions.""",
            
            'technical_analysis': """You are a technical security analyst. Provide:
- Root cause analysis
- Attack mechanism
- Technical impact
- Detection recommendations

Use technical depth for security professionals.""",
            
            'product_analysis': """You are a product security analyst. Analyze:
- Vulnerability trends
- Risk assessment
- Security recommendations
- Vendor practices

Provide actionable insights."""
        }
        
        logger.info(f"Initializing HF inference engine on {self.device}")
        if self.use_fine_tuned:
            logger.info(f"Using fine-tuned model from: {self.fine_tuned_path}")
        else:
            logger.info(f"Using base model: {self.model_name}")
        
        self._load_model()
    
    def _load_token(self) -> str:
        """Load Hugging Face token from file"""
        token_file = Path("llama_token.txt")
        if token_file.exists():
            with open(token_file, 'r') as f:
                token = f.read().strip()
            logger.info("✅ Hugging Face token loaded")
            return token
        else:
            raise FileNotFoundError("llama_token.txt not found. Please create this file with your Hugging Face token.")
    
    def _authenticate(self):
        """Authenticate with Hugging Face"""
        try:
            # Set environment variable for token
            os.environ["HF_TOKEN"] = self.token
            login(token=self.token)
            logger.info("✅ Successfully authenticated with Hugging Face")
        except Exception as e:
            logger.error(f"❌ Authentication failed: {e}")
            raise
    
    def _load_model(self):
        """Load the model and tokenizer"""
        try:
            if self.use_fine_tuned:
                self._load_fine_tuned_model()
            else:
                self._load_base_model()
                
        except Exception as e:
            logger.error(f"Error loading model: {e}")
            raise
    
    def _load_fine_tuned_model(self):
        """Load fine-tuned model with LoRA adapter"""
        if not self.fine_tuned_path.exists():
            logger.error(f"Fine-tuned model not found at {self.fine_tuned_path}")
            logger.info("Falling back to base model...")
            self.use_fine_tuned = False
            self._load_base_model()
            return
        
        logger.info(f"Loading fine-tuned model from {self.fine_tuned_path}")
        
        try:
            # Load LoRA configuration
            config = PeftConfig.from_pretrained(self.fine_tuned_path)
            logger.info(f"Base model: {config.base_model_name_or_path}")
            logger.info(f"Adapter type: {config.peft_type}")
            
            # Load tokenizer from fine-tuned model
            logger.info("Loading tokenizer...")
            self.tokenizer = AutoTokenizer.from_pretrained(self.fine_tuned_path)
            if self.tokenizer.pad_token is None:
                self.tokenizer.pad_token = self.tokenizer.eos_token
            
            # Load base model
            logger.info("Loading base model...")
            base_model = AutoModelForCausalLM.from_pretrained(
                config.base_model_name_or_path,
                token=self.token,
                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
                device_map="auto" if self.device == "cuda" else None,
                trust_remote_code=True
            )
            
            # Load LoRA adapter
            logger.info("Loading LoRA adapter...")
            self.model = PeftModel.from_pretrained(base_model, self.fine_tuned_path)
            
            if self.device == "cpu":
                self.model = self.model.to(self.device)
            
            logger.info("✅ Fine-tuned model loaded successfully!")
            
        except Exception as e:
            logger.error(f"Failed to load fine-tuned model: {e}")
            logger.info("Falling back to base model...")
            self.use_fine_tuned = False
            self._load_base_model()
    
    def _load_base_model(self):
        """Load base model"""
        logger.info(f"Loading tokenizer for {self.model_name}...")
        self.tokenizer = AutoTokenizer.from_pretrained(
            self.model_name,
            token=self.token,
            trust_remote_code=True
        )
        
        logger.info(f"Loading model for {self.model_name}...")
        self.model = AutoModelForCausalLM.from_pretrained(
            self.model_name,
            token=self.token,
            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
            device_map="auto" if self.device == "cuda" else None,
            trust_remote_code=True
        )
        
        if self.device == "cpu":
            self.model = self.model.to(self.device)
        
        logger.info("✅ Base model and tokenizer loaded successfully")
    
    def generate_response(self, query: str, context: List[Dict[str, Any]], 
                         analysis_type: str = 'vulnerability_analysis') -> str:
        """Generate response using the loaded model"""
        if not self.model or not self.tokenizer:
            return "Error: Model not loaded"
        
        try:
            # Build context text
            context_text = self._build_context_text(context)
            
            # Choose prompt format based on model type
            if self.use_fine_tuned:
                # Use instruction format for fine-tuned model
                full_prompt = self._format_prompt_for_fine_tuned(query, context_text, analysis_type)
            else:
                # Use system prompt format for base model
                full_prompt = self._format_prompt_for_base_model(query, context_text, analysis_type)
            
            # Tokenize
            inputs = self.tokenizer(full_prompt, return_tensors="pt", truncation=True, max_length=2048)
            inputs = {k: v.to(self.device) for k, v in inputs.items()}
            
            # Generate
            with torch.no_grad():
                outputs = self.model.generate(
                    **inputs,
                    max_new_tokens=512,
                    temperature=0.3,
                    top_p=0.9,
                    do_sample=True,
                    pad_token_id=self.tokenizer.eos_token_id
                )
            
            # Decode response and clean up
            response = self.tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
            
            # Clean up any artifacts from the model output
            response = response.replace('<|eot_id|>', '').replace('ocausticassist', '').strip()
            return response
            
        except Exception as e:
            logger.error(f"Error generating response: {e}")
            return f"Error: {str(e)}"
    
    def _format_prompt_for_fine_tuned(self, query: str, context_text: str, analysis_type: str) -> str:
        """Format prompt for fine-tuned model using instruction format"""
        # Map analysis type to instruction
        instruction_map = {
            'vulnerability_analysis': "Analyze this CVE vulnerability and provide a comprehensive security assessment.",
            'remediation': "Provide comprehensive remediation guidance with MITRE ATT&CK mitigations for this CVE vulnerability.",
            'technical_analysis': "Provide a detailed technical analysis with MITRE ATT&CK context for this CVE vulnerability.",
            'detection': "Create comprehensive detection strategies for this CVE vulnerability.",
            'mitigation': "Develop a comprehensive mitigation strategy for this CVE vulnerability."
        }
        
        instruction = instruction_map.get(analysis_type, "Analyze this cybersecurity query and provide a comprehensive response.")
        
        return f"""### Instruction:
{instruction}

### Input:
CVE Information:
{context_text}

Question: {query}

### Response:
"""
    
    def _format_prompt_for_base_model(self, query: str, context_text: str, analysis_type: str) -> str:
        """Format prompt for base model using system prompt format"""
        # Get system prompt
        system_prompt = self.system_prompts.get(analysis_type, self.system_prompts['vulnerability_analysis'])
        
        # Build full prompt for Llama 3
        return f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>

{system_prompt}<|eot_id|><|start_header_id|>user<|end_header_id|>

CVE Information:
{context_text}

Question: {query}<|eot_id|><|start_header_id|>assistant<|end_header_id|>

"""
    
    def _build_context_text(self, context: List[Dict[str, Any]]) -> str:
        """Build context text from CVE data"""
        if not context:
            return "No CVE data provided."
        
        context_parts = []
        for item in context:
            if isinstance(item, dict):
                if 'cve_id' in item:
                    context_parts.append(f"CVE ID: {item['cve_id']}")
                if 'description' in item:
                    context_parts.append(f"Description: {item['description']}")
                if 'cvss_v3' in item and 'base_score' in item['cvss_v3']:
                    context_parts.append(f"CVSS Score: {item['cvss_v3']['base_score']}")
                if 'products' in item:
                    products = ", ".join(item['products'][:5])  # Limit to 5 products
                    context_parts.append(f"Affected Products: {products}")
        
        return "\n".join(context_parts)
    
    def analyze_cve(self, cve_id: str, cve_data: Dict[str, Any]) -> str:
        """Analyze a specific CVE"""
        context = [cve_data]
        return self.generate_response(f"Analyze CVE {cve_id}", context, 'vulnerability_analysis')
    
    def get_remediation_plan(self, cve_id: str, cve_data: Dict[str, Any]) -> str:
        """Get remediation plan for a CVE"""
        context = [cve_data]
        return self.generate_response(f"Provide remediation plan for CVE {cve_id}", context, 'remediation')
    
    def analyze_product_security(self, product_name: str, cve_list: List[Dict[str, Any]]) -> str:
        """Analyze security for a specific product"""
        context = cve_list[:5]  # Limit to top 5 CVEs
        return self.generate_response(f"Analyze security for {product_name}", context, 'product_analysis')

def main():
    """Main function to test the inference engine"""
    import argparse
    
    parser = argparse.ArgumentParser(description="CVE LLM Inference Engine")
    parser.add_argument("--use_fine_tuned", action="store_true", 
                       help="Use fine-tuned model instead of base model")
    parser.add_argument("--fine_tuned_path", default="models/fine_tuned_cve_production",
                       help="Path to fine-tuned model")
    parser.add_argument("--query", default="Analyze CVE-2021-44228 Log4j vulnerability",
                       help="Test query to run")
    
    args = parser.parse_args()
    
    try:
        # Initialize inference engine
        engine = HFCVEInferenceEngine(
            use_fine_tuned=args.use_fine_tuned,
            fine_tuned_path=args.fine_tuned_path
        )
        
        # Test with sample CVE data
        sample_cve = {
            'cve_id': 'CVE-2021-44228',
            'description': 'Apache Log4j2 2.0-beta9 through 2.14.1 JNDI features used in configuration, log messages, and parameters do not protect against attacker controlled LDAP and other JNDI related endpoints.',
            'cvss_v3': {'base_score': 10.0, 'base_severity': 'CRITICAL'},
            'products': ['Apache Log4j2']
        }
        
        # Test different analysis types
        print("\n" + "="*60)
        print("TESTING CVE ANALYSIS")
        print("="*60)
        
        # Vulnerability analysis
        print("\n1. VULNERABILITY ANALYSIS:")
        print("-" * 40)
        response = engine.analyze_cve('CVE-2021-44228', sample_cve)
        print(response)
        
        # Remediation plan
        print("\n2. REMEDIATION PLAN:")
        print("-" * 40)
        response = engine.get_remediation_plan('CVE-2021-44228', sample_cve)
        print(response)
        
        # Custom query
        print("\n3. CUSTOM QUERY:")
        print("-" * 40)
        response = engine.generate_response(args.query, [sample_cve], 'vulnerability_analysis')
        print(response)
        
        print(f"\n✅ Inference engine test completed successfully!")
        print(f"Model type: {'Fine-tuned' if args.use_fine_tuned else 'Base'}")
        
    except Exception as e:
        logger.error(f"❌ Inference engine test failed: {e}")
        raise

if __name__ == "__main__":
    main() 

	#!/usr/bin/env python3
	"""
	Hugging Face Inference Engine for CVE Cybersecurity LLM
	Uses Llama 3.1 8B model for CVE analysis and security recommendations.
	Supports both base model and fine-tuned models.
	"""

	import json
	import logging
	import time
	import os
	from pathlib import Path
	from typing import Dict, List, Any, Optional
	import sys

	# Add project root to path
	project_root = Path(__file__).parent.parent.parent
	sys.path.insert(0, str(project_root))

	from config import Config

	# Import transformers
	try:
	from transformers import AutoTokenizer, AutoModelForCausalLM
	from peft import PeftModel, PeftConfig
	import torch
	from torch.nn import functional as F
	from huggingface_hub import login
	except ImportError as e:
	print(f"Error importing transformers: {e}")
	print("Please install: pip install transformers torch accelerate peft")
	sys.exit(1)

	# Configure logging
	logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
	logger = logging.getLogger(__name__)

	class HFCVEInferenceEngine:
	"""Hugging Face inference engine for CVE cybersecurity analysis"""

	def __init__(self, model_name: str = "meta-llama/Meta-Llama-3-8B", use_fine_tuned: bool = False, fine_tuned_path: str = "models/fine_tuned_cve_production"):
	self.config = Config()
	self.model_name = model_name
	self.device = "cuda" if torch.cuda.is_available() else "cpu"
	self.use_fine_tuned = use_fine_tuned
	self.fine_tuned_path = Path(fine_tuned_path)

	# Load and authenticate with token
	self.token = self._load_token()
	self._authenticate()

	# Initialize model and tokenizer
	self.tokenizer = None
	self.model = None

	# System prompts for different analysis types
	self.system_prompts = {
	'vulnerability_analysis': """You are a cybersecurity expert. Analyze the CVE and provide:
	- Severity assessment (Critical/High/Medium/Low)
	- Key technical details
	- Impact analysis
	- Brief remediation steps

	Keep responses concise and actionable.""",

	'remediation': """You are a cybersecurity specialist. Provide specific remediation steps:
	- Immediate actions
	- Patch information
	- Workarounds
	- Verification steps

	Focus on practical solutions.""",

	'technical_analysis': """You are a technical security analyst. Provide:
	- Root cause analysis
	- Attack mechanism
	- Technical impact
	- Detection recommendations

	Use technical depth for security professionals.""",

	'product_analysis': """You are a product security analyst. Analyze:
	- Vulnerability trends
	- Risk assessment
	- Security recommendations
	- Vendor practices

	Provide actionable insights."""
	}

	logger.info(f"Initializing HF inference engine on {self.device}")
	if self.use_fine_tuned:
	logger.info(f"Using fine-tuned model from: {self.fine_tuned_path}")
	else:
	logger.info(f"Using base model: {self.model_name}")

	self._load_model()

	def _load_token(self) -> str:
	"""Load Hugging Face token from file"""
	token_file = Path("llama_token.txt")
	if token_file.exists():
	with open(token_file, 'r') as f:
	token = f.read().strip()
	logger.info("✅ Hugging Face token loaded")
	return token
	else:
	raise FileNotFoundError("llama_token.txt not found. Please create this file with your Hugging Face token.")

	def _authenticate(self):
	"""Authenticate with Hugging Face"""
	try:
	# Set environment variable for token
	os.environ["HF_TOKEN"] = self.token
	login(token=self.token)
	logger.info("✅ Successfully authenticated with Hugging Face")
	except Exception as e:
	logger.error(f"❌ Authentication failed: {e}")
	raise

	def _load_model(self):
	"""Load the model and tokenizer"""
	try:
	if self.use_fine_tuned:
	self._load_fine_tuned_model()
	else:
	self._load_base_model()

	except Exception as e:
	logger.error(f"Error loading model: {e}")
	raise

	def _load_fine_tuned_model(self):
	"""Load fine-tuned model with LoRA adapter"""
	if not self.fine_tuned_path.exists():
	logger.error(f"Fine-tuned model not found at {self.fine_tuned_path}")
	logger.info("Falling back to base model...")
	self.use_fine_tuned = False
	self._load_base_model()
	return

	logger.info(f"Loading fine-tuned model from {self.fine_tuned_path}")

	try:
	# Load LoRA configuration
	config = PeftConfig.from_pretrained(self.fine_tuned_path)
	logger.info(f"Base model: {config.base_model_name_or_path}")
	logger.info(f"Adapter type: {config.peft_type}")

	# Load tokenizer from fine-tuned model
	logger.info("Loading tokenizer...")
	self.tokenizer = AutoTokenizer.from_pretrained(self.fine_tuned_path)
	if self.tokenizer.pad_token is None:
	self.tokenizer.pad_token = self.tokenizer.eos_token

	# Load base model
	logger.info("Loading base model...")
	base_model = AutoModelForCausalLM.from_pretrained(
	config.base_model_name_or_path,
	token=self.token,
	torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
	device_map="auto" if self.device == "cuda" else None,
	trust_remote_code=True
	)

	# Load LoRA adapter
	logger.info("Loading LoRA adapter...")
	self.model = PeftModel.from_pretrained(base_model, self.fine_tuned_path)

	if self.device == "cpu":
	self.model = self.model.to(self.device)

	logger.info("✅ Fine-tuned model loaded successfully!")

	except Exception as e:
	logger.error(f"Failed to load fine-tuned model: {e}")
	logger.info("Falling back to base model...")
	self.use_fine_tuned = False
	self._load_base_model()

	def _load_base_model(self):
	"""Load base model"""
	logger.info(f"Loading tokenizer for {self.model_name}...")
	self.tokenizer = AutoTokenizer.from_pretrained(
	self.model_name,
	token=self.token,
	trust_remote_code=True
	)

	logger.info(f"Loading model for {self.model_name}...")
	self.model = AutoModelForCausalLM.from_pretrained(
	self.model_name,
	token=self.token,
	torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
	device_map="auto" if self.device == "cuda" else None,
	trust_remote_code=True
	)

	if self.device == "cpu":
	self.model = self.model.to(self.device)

	logger.info("✅ Base model and tokenizer loaded successfully")

	def generate_response(self, query: str, context: List[Dict[str, Any]],
	analysis_type: str = 'vulnerability_analysis') -> str:
	"""Generate response using the loaded model"""
	if not self.model or not self.tokenizer:
	return "Error: Model not loaded"

	try:
	# Build context text
	context_text = self._build_context_text(context)

	# Choose prompt format based on model type
	if self.use_fine_tuned:
	# Use instruction format for fine-tuned model
	full_prompt = self._format_prompt_for_fine_tuned(query, context_text, analysis_type)
	else:
	# Use system prompt format for base model
	full_prompt = self._format_prompt_for_base_model(query, context_text, analysis_type)

	# Tokenize
	inputs = self.tokenizer(full_prompt, return_tensors="pt", truncation=True, max_length=2048)
	inputs = {k: v.to(self.device) for k, v in inputs.items()}

	# Generate
	with torch.no_grad():
	outputs = self.model.generate(
	**inputs,
	max_new_tokens=512,
	temperature=0.3,
	top_p=0.9,
	do_sample=True,
	pad_token_id=self.tokenizer.eos_token_id
	)

	# Decode response and clean up
	response = self.tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)

	# Clean up any artifacts from the model output
	response = response.replace('<\|eot_id\|>', '').replace('ocausticassist', '').strip()
	return response

	except Exception as e:
	logger.error(f"Error generating response: {e}")
	return f"Error: {str(e)}"

	def _format_prompt_for_fine_tuned(self, query: str, context_text: str, analysis_type: str) -> str:
	"""Format prompt for fine-tuned model using instruction format"""
	# Map analysis type to instruction
	instruction_map = {
	'vulnerability_analysis': "Analyze this CVE vulnerability and provide a comprehensive security assessment.",
	'remediation': "Provide comprehensive remediation guidance with MITRE ATT&CK mitigations for this CVE vulnerability.",
	'technical_analysis': "Provide a detailed technical analysis with MITRE ATT&CK context for this CVE vulnerability.",
	'detection': "Create comprehensive detection strategies for this CVE vulnerability.",
	'mitigation': "Develop a comprehensive mitigation strategy for this CVE vulnerability."
	}

	instruction = instruction_map.get(analysis_type, "Analyze this cybersecurity query and provide a comprehensive response.")

	return f"""### Instruction:
	{instruction}

	### Input:
	CVE Information:
	{context_text}

	Question: {query}

	### Response:
	"""

	def _format_prompt_for_base_model(self, query: str, context_text: str, analysis_type: str) -> str:
	"""Format prompt for base model using system prompt format"""
	# Get system prompt
	system_prompt = self.system_prompts.get(analysis_type, self.system_prompts['vulnerability_analysis'])

	# Build full prompt for Llama 3
	return f"""<\|begin_of_text\|><\|start_header_id\|>system<\|end_header_id\|>

	{system_prompt}<\|eot_id\|><\|start_header_id\|>user<\|end_header_id\|>

	CVE Information:
	{context_text}

	Question: {query}<\|eot_id\|><\|start_header_id\|>assistant<\|end_header_id\|>

	"""

	def _build_context_text(self, context: List[Dict[str, Any]]) -> str:
	"""Build context text from CVE data"""
	if not context:
	return "No CVE data provided."

	context_parts = []
	for item in context:
	if isinstance(item, dict):
	if 'cve_id' in item:
	context_parts.append(f"CVE ID: {item['cve_id']}")
	if 'description' in item:
	context_parts.append(f"Description: {item['description']}")
	if 'cvss_v3' in item and 'base_score' in item['cvss_v3']:
	context_parts.append(f"CVSS Score: {item['cvss_v3']['base_score']}")
	if 'products' in item:
	products = ", ".join(item['products'][:5]) # Limit to 5 products
	context_parts.append(f"Affected Products: {products}")

	return "\n".join(context_parts)

	def analyze_cve(self, cve_id: str, cve_data: Dict[str, Any]) -> str:
	"""Analyze a specific CVE"""
	context = [cve_data]
	return self.generate_response(f"Analyze CVE {cve_id}", context, 'vulnerability_analysis')

	def get_remediation_plan(self, cve_id: str, cve_data: Dict[str, Any]) -> str:
	"""Get remediation plan for a CVE"""
	context = [cve_data]
	return self.generate_response(f"Provide remediation plan for CVE {cve_id}", context, 'remediation')

	def analyze_product_security(self, product_name: str, cve_list: List[Dict[str, Any]]) -> str:
	"""Analyze security for a specific product"""
	context = cve_list[:5] # Limit to top 5 CVEs
	return self.generate_response(f"Analyze security for {product_name}", context, 'product_analysis')

	def main():
	"""Main function to test the inference engine"""
	import argparse

	parser = argparse.ArgumentParser(description="CVE LLM Inference Engine")
	parser.add_argument("--use_fine_tuned", action="store_true",
	help="Use fine-tuned model instead of base model")
	parser.add_argument("--fine_tuned_path", default="models/fine_tuned_cve_production",
	help="Path to fine-tuned model")
	parser.add_argument("--query", default="Analyze CVE-2021-44228 Log4j vulnerability",
	help="Test query to run")

	args = parser.parse_args()

	try:
	# Initialize inference engine
	engine = HFCVEInferenceEngine(
	use_fine_tuned=args.use_fine_tuned,
	fine_tuned_path=args.fine_tuned_path
	)

	# Test with sample CVE data
	sample_cve = {
	'cve_id': 'CVE-2021-44228',
	'description': 'Apache Log4j2 2.0-beta9 through 2.14.1 JNDI features used in configuration, log messages, and parameters do not protect against attacker controlled LDAP and other JNDI related endpoints.',
	'cvss_v3': {'base_score': 10.0, 'base_severity': 'CRITICAL'},
	'products': ['Apache Log4j2']
	}

	# Test different analysis types
	print("\n" + "="*60)
	print("TESTING CVE ANALYSIS")
	print("="*60)

	# Vulnerability analysis
	print("\n1. VULNERABILITY ANALYSIS:")
	print("-" * 40)
	response = engine.analyze_cve('CVE-2021-44228', sample_cve)
	print(response)

	# Remediation plan
	print("\n2. REMEDIATION PLAN:")
	print("-" * 40)
	response = engine.get_remediation_plan('CVE-2021-44228', sample_cve)
	print(response)

	# Custom query
	print("\n3. CUSTOM QUERY:")
	print("-" * 40)
	response = engine.generate_response(args.query, [sample_cve], 'vulnerability_analysis')
	print(response)

	print(f"\n✅ Inference engine test completed successfully!")
	print(f"Model type: {'Fine-tuned' if args.use_fine_tuned else 'Base'}")

	except Exception as e:
	logger.error(f"❌ Inference engine test failed: {e}")
	raise

	if __name__ == "__main__":
	main()