Privacy by Design: Ollama GDPR Article 25 Implementation Guide

# Check available memory (minimum 8GB recommended)
free -h

# Verify NVIDIA GPU support (optional but recommended)
nvidia-smi

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Verify installation
ollama --version

# Create isolated environment for privacy-sensitive processing
export OLLAMA_HOST=127.0.0.1:11434
export OLLAMA_MODELS=/secure/ollama/models

# Download privacy-optimized model (runs locally only)
ollama pull llama2:7b

# Test local processing (no external network calls)
ollama run llama2:7b "Explain data minimization principles"

# privacy_handler.py - GDPR Article 25 implementation
import logging
import hashlib
import json
from datetime import datetime, timedelta
from typing import Dict, Any, Optional

class GDPRPrivacyHandler:
    """
    Implements Privacy by Design principles for Ollama processing
    Ensures GDPR Article 25 compliance through technical measures
    """
    
    def __init__(self, retention_days: int = 30):
        self.retention_days = retention_days
        self.processing_log = []
        
        # Configure privacy-focused logging
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - GDPR - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def anonymize_data(self, text: str) -> str:
        """
        Apply data minimization through anonymization
        Removes or hashes personally identifiable information
        """
        # Hash potential PII patterns
        import re
        
        # Replace email addresses with hashes
        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
        text = re.sub(email_pattern, lambda m: f"EMAIL_{hashlib.sha256(m.group().encode()).hexdigest()[:8]}", text)
        
        # Replace phone numbers with hashes
        phone_pattern = r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b'
        text = re.sub(phone_pattern, lambda m: f"PHONE_{hashlib.sha256(m.group().encode()).hexdigest()[:8]}", text)
        
        self.logger.info("Applied data minimization to input text")
        return text
    
    def process_with_purpose_limitation(self, prompt: str, purpose: str) -> Dict[str, Any]:
        """
        Process data with explicit purpose limitation
        Records processing purpose for audit compliance
        """
        processing_id = hashlib.sha256(f"{prompt}{datetime.now().isoformat()}".encode()).hexdigest()[:12]
        
        # Record processing purpose and legal basis
        processing_record = {
            "id": processing_id,
            "timestamp": datetime.now().isoformat(),
            "purpose": purpose,
            "legal_basis": "legitimate_interest",
            "data_minimized": True,
            "retention_until": (datetime.now() + timedelta(days=self.retention_days)).isoformat()
        }
        
        self.processing_log.append(processing_record)
        self.logger.info(f"Processing {processing_id} for purpose: {purpose}")
        
        return processing_record
    
    def export_processing_log(self) -> str:
        """
        Export processing log for GDPR audit compliance
        Provides transparency required by Article 25
        """
        return json.dumps(self.processing_log, indent=2)
    
    def cleanup_expired_data(self):
        """
        Automatic data deletion based on retention policies
        Implements storage limitation principle
        """
        current_time = datetime.now()
        
        # Remove expired processing logs
        self.processing_log = [
            record for record in self.processing_log
            if datetime.fromisoformat(record["retention_until"]) > current_time
        ]
        
        self.logger.info(f"Cleaned up expired processing records")

# Example usage with Ollama integration
def privacy_compliant_ai_processing():
    """
    Demonstrate GDPR Article 25 compliant AI processing
    """
    import subprocess
    
    privacy_handler = GDPRPrivacyHandler(retention_days=30)
    
    # Sample user input with PII
    user_input = "Hi, my email is john.doe@company.com and my phone is 555-123-4567. Can you help me analyze customer feedback?"
    
    # Apply privacy by design principles
    anonymized_input = privacy_handler.anonymize_data(user_input)
    processing_record = privacy_handler.process_with_purpose_limitation(
        anonymized_input, 
        "customer_feedback_analysis"
    )
    
    # Process with local Ollama (no external data transmission)
    try:
        result = subprocess.run(
            ["ollama", "run", "llama2:7b", anonymized_input],
            capture_output=True,
            text=True,
            timeout=60
        )
        
        print(f"Processing ID: {processing_record['id']}")
        print(f"Original input: {user_input}")
        print(f"Anonymized input: {anonymized_input}")
        print(f"AI Response: {result.stdout}")
        
    except subprocess.TimeoutExpired:
        print("Processing timeout - check Ollama configuration")
    
    # Export audit log for compliance
    audit_log = privacy_handler.export_processing_log()
    with open("gdpr_processing_log.json", "w") as f:
        f.write(audit_log)

if __name__ == "__main__":
    privacy_compliant_ai_processing()

# docker-compose.yml - Isolated Ollama deployment
version: '3.8'

services:
  ollama-privacy:
    image: ollama/ollama:latest
    container_name: gdpr-compliant-ollama
    networks:
      - privacy_network
    volumes:
      - ./models:/root/.ollama
      - ./logs:/var/log/ollama
    environment:
      - OLLAMA_HOST=0.0.0.0:11434
      - OLLAMA_MODELS=/root/.ollama/models
    ports:
      - "127.0.0.1:11434:11434"  # Bind to localhost only
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp:noexec,nosuid,size=1g
    
  privacy-proxy:
    image: nginx:alpine
    container_name: privacy-proxy
    networks:
      - privacy_network
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/ssl/certs:ro
    ports:
      - "443:443"
    depends_on:
      - ollama-privacy

networks:
  privacy_network:
    driver: bridge
    internal: true  # No external internet access

# audit_monitor.py - GDPR Article 25 audit system
import json
import logging
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Any

class GDPRAuditMonitor:
    """
    Comprehensive audit monitoring for Privacy by Design compliance
    Tracks all data processing activities for regulatory oversight
    """
    
    def __init__(self, audit_dir: str = "./audit_logs"):
        self.audit_dir = Path(audit_dir)
        self.audit_dir.mkdir(exist_ok=True)
        
        # Configure audit-specific logging
        self.audit_logger = logging.getLogger("gdpr_audit")
        handler = logging.FileHandler(self.audit_dir / "gdpr_audit.log")
        handler.setFormatter(logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        ))
        self.audit_logger.addHandler(handler)
        self.audit_logger.setLevel(logging.INFO)
    
    def log_data_processing(self, event_type: str, details: Dict[str, Any]):
        """
        Log data processing events for GDPR Article 25 compliance
        Creates immutable audit trail
        """
        audit_entry = {
            "timestamp": datetime.now().isoformat(),
            "event_type": event_type,
            "details": details,
            "compliance_check": self._validate_gdpr_compliance(details)
        }
        
        # Write to immutable audit log
        audit_file = self.audit_dir / f"audit_{datetime.now().strftime('%Y%m%d')}.jsonl"
        with open(audit_file, "a") as f:
            f.write(json.dumps(audit_entry) + "\n")
        
        self.audit_logger.info(f"Logged {event_type}: {details.get('processing_id', 'unknown')}")
    
    def _validate_gdpr_compliance(self, details: Dict[str, Any]) -> Dict[str, bool]:
        """
        Validate processing against GDPR Article 25 requirements
        """
        compliance_checks = {
            "data_minimization_applied": details.get("anonymized", False),
            "purpose_limitation_defined": bool(details.get("purpose")),
            "retention_policy_set": bool(details.get("retention_until")),
            "local_processing_only": details.get("external_apis_used", 0) == 0,
            "consent_recorded": bool(details.get("consent_basis")),
            "security_measures_active": details.get("encryption_enabled", True)
        }
        
        return compliance_checks
    
    def generate_compliance_report(self, start_date: str, end_date: str) -> Dict[str, Any]:
        """
        Generate GDPR compliance report for specified date range
        Useful for regulatory audits and privacy impact assessments
        """
        audit_files = list(self.audit_dir.glob("audit_*.jsonl"))
        processed_events = []
        
        for audit_file in audit_files:
            with open(audit_file) as f:
                for line in f:
                    event = json.loads(line.strip())
                    event_date = event["timestamp"][:10]  # Extract date
                    
                    if start_date <= event_date <= end_date:
                        processed_events.append(event)
        
        # Analyze compliance metrics
        total_events = len(processed_events)
        compliance_scores = {}
        
        if total_events > 0:
            for check_name in ["data_minimization_applied", "purpose_limitation_defined", 
                             "retention_policy_set", "local_processing_only"]:
                passed_checks = sum(1 for event in processed_events 
                                  if event["compliance_check"].get(check_name, False))
                compliance_scores[check_name] = (passed_checks / total_events) * 100
        
        report = {
            "report_period": {"start": start_date, "end": end_date},
            "total_processing_events": total_events,
            "compliance_scores": compliance_scores,
            "gdpr_article_25_status": "COMPLIANT" if all(score >= 95 for score in compliance_scores.values()) else "REVIEW_REQUIRED",
            "generated_at": datetime.now().isoformat()
        }
        
        return report

# Integration with Ollama processing
def monitored_ollama_processing(prompt: str, purpose: str) -> str:
    """
    Process AI requests with full GDPR audit monitoring
    """
    import subprocess
    import uuid
    
    audit_monitor = GDPRAuditMonitor()
    privacy_handler = GDPRPrivacyHandler()
    
    # Generate unique processing ID
    processing_id = str(uuid.uuid4())
    
    # Pre-processing audit log
    audit_monitor.log_data_processing("processing_started", {
        "processing_id": processing_id,
        "purpose": purpose,
        "anonymized": True,
        "retention_until": (datetime.now() + timedelta(days=30)).isoformat(),
        "external_apis_used": 0,
        "encryption_enabled": True,
        "consent_basis": "legitimate_interest"
    })
    
    try:
        # Apply privacy controls
        anonymized_prompt = privacy_handler.anonymize_data(prompt)
        
        # Process with local Ollama
        result = subprocess.run(
            ["ollama", "run", "llama2:7b", anonymized_prompt],
            capture_output=True,
            text=True,
            timeout=60
        )
        
        # Post-processing audit log
        audit_monitor.log_data_processing("processing_completed", {
            "processing_id": processing_id,
            "success": result.returncode == 0,
            "output_length": len(result.stdout),
            "processing_time_seconds": 60  # Would be actual time in production
        })
        
        return result.stdout
        
    except Exception as e:
        # Error audit log
        audit_monitor.log_data_processing("processing_error", {
            "processing_id": processing_id,
            "error_type": type(e).__name__,
            "error_message": str(e)
        })
        raise

# Example usage
if __name__ == "__main__":
    # Process a privacy-sensitive request
    response = monitored_ollama_processing(
        "Analyze customer satisfaction trends from recent surveys",
        "business_analytics"
    )
    
    print("AI Response:", response)
    
    # Generate monthly compliance report
    audit_monitor = GDPRAuditMonitor()
    report = audit_monitor.generate_compliance_report("2025-07-01", "2025-07-31")
    print("\nCompliance Report:", json.dumps(report, indent=2))

# differential_privacy.py - Enhanced privacy protection
import numpy as np
from typing import List, Tuple
import hashlib

class DifferentialPrivacyEngine:
    """
    Implements differential privacy for enhanced GDPR Article 25 compliance
    Provides mathematical privacy guarantees beyond basic anonymization
    """
    
    def __init__(self, epsilon: float = 1.0, delta: float = 1e-5):
        self.epsilon = epsilon  # Privacy budget
        self.delta = delta      # Failure probability
    
    def add_noise_to_text_metrics(self, text: str) -> Dict[str, float]:
        """
        Add calibrated noise to text analysis metrics
        Preserves utility while ensuring differential privacy
        """
        # Calculate base metrics
        word_count = len(text.split())
        char_count = len(text)
        sentiment_score = self._simple_sentiment(text)
        
        # Add Laplace noise for differential privacy
        noise_scale = 1.0 / self.epsilon
        
        noisy_metrics = {
            "word_count": max(0, word_count + np.random.laplace(0, noise_scale)),
            "char_count": max(0, char_count + np.random.laplace(0, noise_scale * 10)),
            "sentiment": np.clip(sentiment_score + np.random.laplace(0, noise_scale), -1, 1)
        }
        
        return noisy_metrics
    
    def _simple_sentiment(self, text: str) -> float:
        """
        Simple sentiment scoring for demonstration
        In production, use more sophisticated models
        """
        positive_words = ["good", "great", "excellent", "amazing", "wonderful"]
        negative_words = ["bad", "terrible", "awful", "horrible", "disappointing"]
        
        words = text.lower().split()
        positive_count = sum(1 for word in words if word in positive_words)
        negative_count = sum(1 for word in words if word in negative_words)
        
        if positive_count + negative_count == 0:
            return 0.0
        
        return (positive_count - negative_count) / (positive_count + negative_count)
    
    def privacy_budget_tracking(self) -> Dict[str, float]:
        """
        Track privacy budget consumption
        Essential for long-term differential privacy guarantees
        """
        return {
            "epsilon_remaining": max(0, self.epsilon - 0.1),  # Simulated consumption
            "delta_remaining": self.delta,
            "budget_exhausted": False
        }

# Enhanced privacy-compliant processing
def enhanced_privacy_processing(user_input: str) -> Dict[str, Any]:
    """
    Demonstrate advanced privacy engineering with Ollama
    Combines multiple privacy techniques for robust protection
    """
    import subprocess
    
    # Initialize privacy components
    privacy_handler = GDPRPrivacyHandler()
    dp_engine = DifferentialPrivacyEngine(epsilon=1.0)
    audit_monitor = GDPRAuditMonitor()
    
    processing_id = hashlib.sha256(f"{user_input}{datetime.now()}".encode()).hexdigest()[:12]
    
    # Multi-layer privacy protection
    anonymized_input = privacy_handler.anonymize_data(user_input)
    privacy_metrics = dp_engine.add_noise_to_text_metrics(anonymized_input)
    budget_status = dp_engine.privacy_budget_tracking()
    
    # Process with enhanced privacy controls
    try:
        result = subprocess.run(
            ["ollama", "run", "llama2:7b", f"Analyze this feedback: {anonymized_input}"],
            capture_output=True,
            text=True,
            timeout=60
        )
        
        # Comprehensive audit logging
        audit_monitor.log_data_processing("enhanced_privacy_processing", {
            "processing_id": processing_id,
            "privacy_techniques": ["anonymization", "differential_privacy", "local_processing"],
            "privacy_budget_used": 0.1,
            "privacy_metrics": privacy_metrics,
            "budget_status": budget_status,
            "gdpr_article_25_compliance": True
        })
        
        return {
            "processing_id": processing_id,
            "anonymized_response": result.stdout,
            "privacy_metrics": privacy_metrics,
            "compliance_status": "GDPR_ARTICLE_25_COMPLIANT"
        }
        
    except Exception as e:
        audit_monitor.log_data_processing("processing_error", {
            "processing_id": processing_id,
            "error": str(e)
        })
        raise

if __name__ == "__main__":
    # Test enhanced privacy processing
    sample_input = "Customer John Smith at john@email.com complained about delayed delivery. Phone: 555-0123."
    
    result = enhanced_privacy_processing(sample_input)
    print("Enhanced Privacy Processing Result:")
    print(json.dumps(result, indent=2))

#!/bin/bash
# compliance_monitor.sh - Automated GDPR compliance checking

# Check Ollama service isolation
check_network_isolation() {
    echo "Checking network isolation..."
    
    # Verify Ollama only binds to localhost
    if netstat -tlnp | grep :11434 | grep -q "127.0.0.1:11434"; then
        echo "✓ Ollama properly isolated to localhost"
    else
        echo "✗ WARNING: Ollama may be exposed externally"
        exit 1
    fi
    
    # Check for external API calls
    if ! ss -tuln | grep :443 | grep -q ESTABLISHED; then
        echo "✓ No external HTTPS connections detected"
    else
        echo "⚠ External connections detected - review for GDPR compliance"
    fi
}

# Verify audit logging
check_audit_logs() {
    echo "Checking audit log integrity..."
    
    local audit_dir="./audit_logs"
    local today=$(date +%Y%m%d)
    
    if [[ -f "$audit_dir/audit_$today.jsonl" ]]; then
        echo "✓ Today's audit log exists"
        
        # Check log entries are valid JSON
        if jq empty "$audit_dir/audit_$today.jsonl" 2>/dev/null; then
            echo "✓ Audit log format valid"
        else
            echo "✗ Audit log format corrupted"
            exit 1
        fi
    else
        echo "⚠ No audit log for today - may indicate processing issues"
    fi
}

# Check privacy controls
check_privacy_controls() {
    echo "Verifying privacy controls..."
    
    # Test anonymization function
    python3 -c "
from privacy_handler import GDPRPrivacyHandler
handler = GDPRPrivacyHandler()
test_input = 'test@email.com and 555-1234'
result = handler.anonymize_data(test_input)
assert 'test@email.com' not in result, 'Email not anonymized'
assert '555-1234' not in result, 'Phone not anonymized'
print('✓ Anonymization working correctly')
"
}

# Generate compliance report
generate_compliance_report() {
    echo "Generating daily compliance report..."
    
    python3 -c "
from audit_monitor import GDPRAuditMonitor
import json
from datetime import datetime, timedelta

monitor = GDPRAuditMonitor()
today = datetime.now().strftime('%Y-%m-%d')
yesterday = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')

report = monitor.generate_compliance_report(yesterday, today)
print('Daily Compliance Report:')
print(json.dumps(report, indent=2))

# Check compliance status
if report['gdpr_article_25_status'] == 'COMPLIANT':
    print('✓ GDPR Article 25 compliance maintained')
else:
    print('✗ Compliance issues detected - review required')
    exit 1
"
}

# Main compliance check
main() {
    echo "Starting GDPR Article 25 compliance check..."
    echo "=========================================="
    
    check_network_isolation
    check_audit_logs
    check_privacy_controls
    generate_compliance_report
    
    echo "=========================================="
    echo "Compliance check completed successfully"
}

# Run compliance check
main

# customer_support_ai.py - GDPR-compliant customer support
class PrivacyCompliantSupportAI:
    """
    Customer support AI that maintains GDPR Article 25 compliance
    Processes customer queries while protecting personal data
    """
    
    def __init__(self):
        self.privacy_handler = GDPRPrivacyHandler()
        self.audit_monitor = GDPRAuditMonitor()
        self.conversation_history = {}
    
    def process_customer_query(self, customer_id: str, query: str, consent_given: bool) -> Dict[str, Any]:
        """
        Process customer support queries with full privacy protection
        """
        if not consent_given:
            return {"error": "Customer consent required for AI processing"}
        
        # Create session-specific processing context
        session_id = hashlib.sha256(f"{customer_id}{datetime.now()}".encode()).hexdigest()[:12]
        
        # Apply privacy controls
        anonymized_query = self.privacy_handler.anonymize_data(query)
        
        # Log processing with purpose limitation
        self.audit_monitor.log_data_processing("customer_support_query", {
            "session_id": session_id,
            "customer_id_hash": hashlib.sha256(customer_id.encode()).hexdigest(),
            "purpose": "customer_support_assistance",
            "consent_given": consent_given,
            "data_minimized": True,
            "retention_until": (datetime.now() + timedelta(days=7)).isoformat()  # Short retention for support
        })
        
        # Process with Ollama
        support_prompt = f"""
        You are a helpful customer support assistant. 
        Respond to this customer query professionally and helpfully.
        Do not ask for or reference any personal information.
        
        Customer query: {anonymized_query}
        """
        
        try:
            result = subprocess.run(
                ["ollama", "run", "llama2:7b", support_prompt],
                capture_output=True,
                text=True,
                timeout=30
            )
            
            response = {
                "session_id": session_id,
                "response": result.stdout.strip(),
                "privacy_compliant": True,
                "processing_timestamp": datetime.now().isoformat()
            }
            
            # Store minimal session data (automatically expires)
            self.conversation_history[session_id] = {
                "timestamp": datetime.now(),
                "anonymized_query": anonymized_query[:100],  # Truncated for minimal storage
                "response_provided": True
            }
            
            return response
            
        except Exception as e:
            self.audit_monitor.log_data_processing("support_processing_error", {
                "session_id": session_id,
                "error": str(e)
            })
            return {"error": "Processing failed", "session_id": session_id}
    
    def cleanup_expired_sessions(self):
        """
        Automatic cleanup of expired conversation data
        Implements storage limitation principle
        """
        cutoff_time = datetime.now() - timedelta(hours=24)
        
        expired_sessions = [
            session_id for session_id, data in self.conversation_history.items()
            if data["timestamp"] < cutoff_time
        ]
        
        for session_id in expired_sessions:
            del self.conversation_history[session_id]
        
        self.audit_monitor.log_data_processing("session_cleanup", {
            "expired_sessions_count": len(expired_sessions),
            "cleanup_timestamp": datetime.now().isoformat()
        })

# Example usage
def demo_customer_support():
    support_ai = PrivacyCompliantSupportAI()
    
    # Simulate customer queries
    queries = [
        {
            "customer_id": "CUST_001", 
            "query": "Hi, I'm John Doe (john@email.com). My order #12345 hasn't arrived yet. Can you help?",
            "consent": True
        },
        {
            "customer_id": "CUST_002",
            "query": "What are your return policies?",
            "consent": True
        }
    ]
    
    for query_data in queries:
        response = support_ai.process_customer_query(
            query_data["customer_id"],
            query_data["query"],
            query_data["consent"]
        )
        
        print(f"Session: {response.get('session_id')}")
        print(f"Response: {response.get('response', 'Error occurred')}")
        print("-" * 50)
    
    # Cleanup expired sessions
    support_ai.cleanup_expired_sessions()

if __name__ == "__main__":
    demo_customer_support()

# document_analyzer.py - Privacy-compliant document processing
class PrivacyCompliantDocumentAnalyzer:
    """
    Analyze documents while maintaining GDPR Article 25 compliance
    Suitable for legal, HR, and business document processing
    """
    
    def __init__(self):
        self.privacy_handler = GDPRPrivacyHandler()
        self.audit_monitor = GDPRAuditMonitor()
    
    def analyze_document(self, document_content: str, analysis_purpose: str, data_controller: str) -> Dict[str, Any]:
        """
        Analyze document content with comprehensive privacy protection
        """
        analysis_id = hashlib.sha256(f"{document_content[:100]}{datetime.now()}".encode()).hexdigest()[:12]
        
        # Pre-processing: Apply data minimization
        anonymized_content = self.privacy_handler.anonymize_data(document_content)
        
        # Extract only necessary information based on purpose
        if analysis_purpose == "contract_review":
            content_for_analysis = self._extract_contract_terms(anonymized_content)
        elif analysis_purpose == "compliance_check":
            content_for_analysis = self._extract_compliance_terms(anonymized_content)
        else:
            content_for_analysis = anonymized_content[:1000]  # Limit content size
        
        # Log processing with full audit trail
        self.audit_monitor.log_data_processing("document_analysis", {
            "analysis_id": analysis_id,
            "purpose": analysis_purpose,
            "data_controller": data_controller,
            "content_length_original": len(document_content),
            "content_length_processed": len(content_for_analysis),
            "anonymization_applied": True,
            "legal_basis": "legitimate_interest",
            "retention_until": (datetime.now() + timedelta(days=90)).isoformat()
        })
        
        # Analyze with Ollama
        analysis_prompt = f"""
        Analyze this document excerpt for {analysis_purpose}.
        Provide a summary focusing on key points relevant to the stated purpose.
        Do not reproduce any personal information in your response.
        
        Document excerpt: {content_for_analysis}
        """
        
        try:
            result = subprocess.run(
                ["ollama", "run", "llama2:7b", analysis_prompt],
                capture_output=True,
                text=True,
                timeout=60
            )
            
            analysis_result = {
                "analysis_id": analysis_id,
                "purpose": analysis_purpose,
                "summary": result.stdout.strip(),
                "confidence_score": self._calculate_confidence(result.stdout),
                "privacy_compliant": True,
                "processed_at": datetime.now().isoformat()
            }
            
            # Final audit log
            self.audit_monitor.log_data_processing("analysis_completed", {
                "analysis_id": analysis_id,
                "success": True,
                "output_length": len(result.stdout)
            })
            
            return analysis_result
            
        except Exception as e:
            self.audit_monitor.log_data_processing("analysis_error", {
                "analysis_id": analysis_id,
                "error": str(e)
            })
            raise
    
    def _extract_contract_terms(self, content: str) -> str:
        """
        Extract contract-relevant terms while preserving privacy
        """
        # Simple keyword-based extraction for demonstration
        keywords = ["term", "condition", "obligation", "liability", "warranty", "payment", "delivery"]
        sentences = content.split('.')
        
        relevant_sentences = []
        for sentence in sentences:
            if any(keyword in sentence.lower() for keyword in keywords):
                relevant_sentences.append(sentence.strip())
        
        return '. '.join(relevant_sentences[:10])  # Limit to first 10 relevant sentences
    
    def _extract_compliance_terms(self, content: str) -> str:
        """
        Extract compliance-relevant terms
        """
        compliance_keywords = ["regulation", "compliance", "audit", "requirement", "standard", "policy"]
        sentences = content.split('.')
        
        relevant_sentences = []
        for sentence in sentences:
            if any(keyword in sentence.lower() for keyword in compliance_keywords):
                relevant_sentences.append(sentence.strip())
        
        return '. '.join(relevant_sentences[:10])
    
    def _calculate_confidence(self, analysis_output: str) -> float:
        """
        Calculate confidence score for analysis quality
        """
        # Simple heuristic based on response length and completeness
        if len(analysis_output) < 50:
            return 0.3
        elif len(analysis_output) < 200:
            return 0.7
        else:
            return 0.9

# Example usage
def demo_document_analysis():
    analyzer = PrivacyCompliantDocumentAnalyzer()
    
    # Sample document with PII
    sample_document = """
    This contract is between John Smith (john.smith@company.com) and ABC Corp.
    The payment terms require settlement within 30 days of invoice.
    Delivery obligations include shipment to 123 Main St, Anytown, State 12345.
    The contract term is 12 months with automatic renewal.
    Contact information: phone 555-0123 for any questions.
    """
    
    # Analyze for different purposes
    purposes = ["contract_review", "compliance_check"]
    
    for purpose in purposes:
        print(f"\nAnalyzing document for: {purpose}")
        print("=" * 40)
        
        result = analyzer.analyze_document(
            sample_document,
            purpose,
            "Legal Department"
        )
        
        print(f"Analysis ID: {result['analysis_id']}")
        print(f"Summary: {result['summary']}")
        print(f"Confidence: {result['confidence_score']}")
        print(f"Privacy Compliant: {result['privacy_compliant']}")

if __name__ == "__main__":
    demo_document_analysis()

# performance_optimizer.py - Production performance optimization
import psutil
import threading
import queue
import time
from typing import List, Dict, Any
from concurrent.futures import ThreadPoolExecutor, as_completed

class PrivacyCompliantPerformanceOptimizer:
    """
    Optimize Ollama performance while maintaining GDPR compliance
    Handles resource management and scaling for production workloads
    """
    
    def __init__(self, max_concurrent_requests: int = 5):
        self.max_concurrent_requests = max_concurrent_requests
        self.request_queue = queue.Queue(maxsize=100)
        self.privacy_handler = GDPRPrivacyHandler()
        self.audit_monitor = GDPRAuditMonitor()
        self.performance_metrics = {
            "requests_processed": 0,
            "average_response_time": 0.0,
            "memory_usage_mb": 0.0,
            "cpu_usage_percent": 0.0
        }
    
    def process_request_batch(self, requests: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        Process multiple requests concurrently while maintaining privacy controls
        """
        batch_id = hashlib.sha256(f"batch_{datetime.now()}".encode()).hexdigest()[:8]
        
        # Pre-validate all requests for GDPR compliance
        validated_requests = []
        for req in requests:
            if self._validate_gdpr_compliance(req):
                validated_requests.append(req)
            else:
                self.audit_monitor.log_data_processing("request_rejected", {
                    "batch_id": batch_id,
                    "reason": "gdpr_compliance_validation_failed"
                })
        
        # Process validated requests concurrently
        results = []
        start_time = time.time()
        
        with ThreadPoolExecutor(max_workers=self.max_concurrent_requests) as executor:
            # Submit all requests
            future_to_request = {
                executor.submit(self._process_single_request, req, batch_id): req 
                for req in validated_requests
            }
            
            # Collect results as they complete
            for future in as_completed(future_to_request):
                request = future_to_request[future]
                try:
                    result = future.result(timeout=60)
                    results.append(result)
                except Exception as e:
                    error_result = {
                        "request_id": request.get("id", "unknown"),
                        "error": str(e),
                        "privacy_compliant": True  # Error doesn't compromise privacy
                    }
                    results.append(error_result)
        
        # Update performance metrics
        processing_time = time.time() - start_time
        self._update_performance_metrics(len(validated_requests), processing_time)
        
        # Log batch completion
        self.audit_monitor.log_data_processing("batch_processed", {
            "batch_id": batch_id,
            "requests_count": len(validated_requests),
            "processing_time_seconds": processing_time,
            "success_rate": len([r for r in results if "error" not in r]) / len(results)
        })
        
        return results
    
    def _process_single_request(self, request: Dict[str, Any], batch_id: str) -> Dict[str, Any]:
        """
        Process individual request with privacy controls
        """
        request_id = request.get("id", hashlib.sha256(str(request).encode()).hexdigest()[:8])
        
        # Apply privacy transformations
        anonymized_input = self.privacy_handler.anonymize_data(request["input"])
        
        # Process with Ollama
        try:
            result = subprocess.run(
                ["ollama", "run", "llama2:7b", anonymized_input],
                capture_output=True,
                text=True,
                timeout=45
            )
            
            return {
                "request_id": request_id,
                "batch_id": batch_id,
                "response": result.stdout.strip(),
                "processing_time": time.time() - request.get("start_time", time.time()),
                "privacy_compliant": True
            }
            
        except subprocess.TimeoutExpired:
            return {
                "request_id": request_id,
                "batch_id": batch_id,
                "error": "Processing timeout",
                "privacy_compliant": True
            }
    
    def _validate_gdpr_compliance(self, request: Dict[str, Any]) -> bool:
        """
        Validate request meets GDPR Article 25 requirements
        """
        required_fields = ["input", "purpose", "consent_given"]
        
        # Check required fields
        if not all(field in request for field in required_fields):
            return False
        
        # Validate consent
        if not request.get("consent_given", False):
            return False
        
        # Check input size (data minimization)
        if len(request["input"]) > 5000:  # Reasonable limit
            return False
        
        return True
    
    def _update_performance_metrics(self, request_count: int, processing_time: float):
        """
        Update performance metrics for monitoring
        """
        self.performance_metrics["requests_processed"] += request_count
        
        # Update average response time
        current_avg = self.performance_metrics["average_response_time"]
        new_avg = (current_avg + (processing_time / request_count)) / 2
        self.performance_metrics["average_response_time"] = new_avg
        
        # Update system metrics
        self.performance_metrics["memory_usage_mb"] = psutil.virtual_memory().used / 1024 / 1024
        self.performance_metrics["cpu_usage_percent"] = psutil.cpu_percent()
    
    def get_performance_report(self) -> Dict[str, Any]:
        """
        Generate performance report for monitoring and optimization
        """
        return {
            "timestamp": datetime.now().isoformat(),
            "metrics": self.performance_metrics.copy(),
            "system_status": {
                "memory_available_gb": psutil.virtual_memory().available / 1024 / 1024 / 1024,
                "cpu_count": psutil.cpu_count(),
                "disk_usage_percent": psutil.disk_usage("/").percent
            },
            "gdpr_compliance_status": "MAINTAINED"
        }

# Production monitoring script
def production_monitoring():
    """
    Continuous monitoring for production Privacy by Design system
    """
    optimizer = PrivacyCompliantPerformanceOptimizer()
    
    # Simulate production request load
    sample_requests = [
        {
            "id": f"req_{i}",
            "input": f"Analyze customer feedback: Great service but delivery was delayed. Contact support@company.com for follow-up.",
            "purpose": "sentiment_analysis",
            "consent_given": True,
            "start_time": time.time()
        }
        for i in range(10)
    ]
    
    print("Processing production request batch...")
    start_time = time.time()
    
    results = optimizer.process_request_batch(sample_requests)
    
    total_time = time.time() - start_time
    print(f"Batch processing completed in {total_time:.2f} seconds")
    
    # Display results summary
    successful_requests = len([r for r in results if "error" not in r])
    print(f"Successful requests: {successful_requests}/{len(results)}")
    
    # Performance report
    performance_report = optimizer.get_performance_report()
    print("\nPerformance Report:")
    print(json.dumps(performance_report, indent=2))

if __name__ == "__main__":
    production_monitoring()