AI Safety & Guardrails

Production Implementation

from openai import OpenAI
import openai
from typing import Dict, List, Optional

class ContentModerator:
    def __init__(self, openai_api_key: str):
        self.client = OpenAI(api_key=openai_api_key)
        
        # Content categories to moderate
        self.moderation_categories = [
            'hate', 'hate/threatening', 'self-harm', 'sexual', 
            'sexual/minors', 'violence', 'violence/graphic'
        ]
    
    def moderate_input(self, text: str) -> Dict:
        """Moderate user input before processing"""
        try:
            response = self.client.moderations.create(input=text)
            result = response.results[0]
            
            return {
                'flagged': result.flagged,
                'categories': result.categories.model_dump(),
                'category_scores': result.category_scores.model_dump(),
                'safe_to_process': not result.flagged
            }
        except Exception as e:
            # Conservative approach: reject on error
            return {
                'flagged': True,
                'error': str(e),
                'safe_to_process': False
            }
    
    def moderate_output(self, generated_text: str) -> Dict:
        """Moderate AI-generated content before showing to user"""
        moderation = self.moderate_input(generated_text)
        
        # Additional custom checks for output
        custom_flags = self.custom_output_checks(generated_text)
        
        return {
            **moderation,
            'custom_flags': custom_flags,
            'safe_to_show': not moderation['flagged'] and not any(custom_flags.values())
        }
    
    def custom_output_checks(self, text: str) -> Dict[str, bool]:
        """Additional custom moderation checks"""
        flags = {
            'contains_personal_info': self.check_personal_info(text),
            'potential_misinformation': self.check_misinformation(text),
            'inappropriate_instructions': self.check_harmful_instructions(text)
        }
        return flags
    
    def check_personal_info(self, text: str) -> bool:
        """Check for potential personal information leakage"""
        import re
        
        # Simple patterns - use more sophisticated detection in production
        patterns = [
            r'\b\d{3}-\d{2}-\d{4}\b',  # SSN pattern
            r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',  # Email
            r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b'  # Credit card
        ]
        
        for pattern in patterns:
            if re.search(pattern, text):
                return True
        return False
    
    def check_misinformation(self, text: str) -> bool:
        """Check for potential misinformation indicators"""
        # This would integrate with fact-checking APIs in production
        misinformation_indicators = [
            'proven fact', 'scientists agree', 'studies show',
            'experts say', 'research confirms'
        ]
        
        # Flag if making strong factual claims without sources
        text_lower = text.lower()
        return any(indicator in text_lower for indicator in misinformation_indicators)
    
    def check_harmful_instructions(self, text: str) -> bool:
        """Check for potentially harmful instructions"""
        harmful_patterns = [
            'how to make', 'instructions for', 'steps to create',
            'recipe for', 'guide to making'
        ]
        
        dangerous_topics = [
            'explosive', 'poison', 'weapon', 'drug synthesis',
            'hacking', 'fraud', 'identity theft'
        ]
        
        text_lower = text.lower()
        has_instruction = any(pattern in text_lower for pattern in harmful_patterns)
        has_danger = any(topic in text_lower for topic in dangerous_topics)
        
        return has_instruction and has_danger

class SafeContentGenerator:
    def __init__(self, openai_api_key: str):
        self.client = OpenAI(api_key=openai_api_key)
        self.moderator = ContentModerator(openai_api_key)
    
    def safe_generate(self, prompt: str, max_retries: int = 3) -> Dict:
        """Generate content with safety checks"""
        
        # Step 1: Moderate input
        input_moderation = self.moderator.moderate_input(prompt)
        if not input_moderation['safe_to_process']:
            return {
                'success': False,
                'error': 'Input blocked by content filter',
                'moderation': input_moderation
            }
        
        # Step 2: Generate with safety prompt
        safe_prompt = self.add_safety_instructions(prompt)
        
        for attempt in range(max_retries):
            try:
                response = self.client.chat.completions.create(
                    model="gpt-4",
                    messages=[
                        {"role": "system", "content": self.get_safety_system_prompt()},
                        {"role": "user", "content": safe_prompt}
                    ],
                    temperature=0.7,
                    max_tokens=1000
                )
                
                generated_text = response.choices[0].message.content
                
                # Step 3: Moderate output
                output_moderation = self.moderator.moderate_output(generated_text)
                
                if output_moderation['safe_to_show']:
                    return {
                        'success': True,
                        'content': generated_text,
                        'moderation': output_moderation,
                        'attempts': attempt + 1
                    }
                
            except Exception as e:
                if attempt == max_retries - 1:
                    return {
                        'success': False,
                        'error': f'Generation failed: {str(e)}'
                    }
        
        return {
            'success': False,
            'error': 'Could not generate safe content after multiple attempts'
        }
    
    def get_safety_system_prompt(self) -> str:
        return """You are a helpful, harmless, and honest AI assistant.

SAFETY GUIDELINES:
- Do not generate harmful, illegal, or unethical content
- Refuse requests for dangerous instructions or information
- Protect privacy and do not generate personal information
- Be truthful and acknowledge uncertainty
- Decline inappropriate requests politely
- Focus on being helpful while maintaining safety

If a request is potentially harmful, explain why you cannot fulfill it and offer a safe alternative."""

    def add_safety_instructions(self, prompt: str) -> str:
        return f"""
Please ensure your response is safe, helpful, and appropriate.

User request: {prompt}

Remember to:
- Avoid any harmful or dangerous content
- Be truthful and factual
- Protect privacy and personal information
- Provide constructive and positive information
"""

# Usage example
safe_generator = SafeContentGenerator(api_key="your-api-key")

result = safe_generator.safe_generate("Write a story about overcoming challenges")
if result['success']:
    print(result['content'])
else:
    print(f"Content generation blocked: {result['error']}")