07. Privacy-Preserving Routing

Privacy requirements often mandate specific handling procedures for sensitive data. Hybrid routing encodes these requirements as enforceable policy constraints. The system inspects requests for protected attributes and routes them to compliant backends without sacrificing operational flexibility.

Data classification establishes sensitivity tiers that inform routing requirements. Public information permits unrestricted routing to any backend. Internal data restricts cloud routing to approved providers. Protected health information requires on-premise processing. Personal identifying information triggers jurisdiction-specific routing rules. Classification metadata accompanies requests through the routing pipeline.

Structured data detection identifies sensitive fields within unstructured prompts. Regex patterns match common identifiers (social security numbers, credit card formats). Named entity recognition locates person names, locations, and organizations. Document type classification handles structured forms with known sensitive field positions. This inspection pipeline provides the classification context that routing decisions require.

Provider qualification confirms which backends satisfy which privacy requirements. Certifications demonstrate compliance posture. Data processing agreements establish contractual obligations. Geographic restrictions limit routing to providers with infrastructure in approved regions. The qualification matrix maps privacy requirements to qualified backends.

python
from enum import Flag, auto
from dataclasses import dataclass, field
from typing import Optional

class PrivacyFlag(Flag):
    """Enumeration of privacy compliance requirements."""
    NONE = 0
    PII_PRESENT = auto()
    PHI_PRESENT = auto()
    GDPR_SUBJECT = auto()
    PCI_SCOPE = auto()
    IP_CONTENT = auto()
    FINANCIAL_DATA = auto()
    CHILD_DATA = auto()

@dataclass
class RequestPrivacyProfile:
    """Privacy profile derived from request inspection."""
    flags: PrivacyFlag
    detected_entities: list[str] = field(default_factory=list)
    jurisdiction: Optional[str] = None
    retention_classification: str = "standard"
    
    def requires_local_only(self) -> bool:
        """Determine if request mandates on-premise processing."""
        return (
            PrivacyFlag.PHI_PRESENT in self.flags or
            PrivacyFlag.CHILD_DATA in self.flags or
            PrivacyFlag.GDPR_SUBJECT in self.flags and 
            self.jurisdiction == "EU"
        )

@dataclass
class QualifiedBackend:
    """Backend with confirmed privacy certifications."""
    name: str
    location: str
    certifications: set[str] = field(default_factory=set)
    jurisdiction: Optional[str] = None
    
    def supports_requirement(self, requirement: PrivacyFlag) -> bool:
        """Check whether backend satisfies a specific privacy flag."""
        # Simplified certification mapping
        CERT_MAP = {
            PrivacyFlag.PHI_PRESENT: {"hipaa"},
            PrivacyFlag.PCI_SCOPE: {"pci-dss"},
            PrivacyFlag.GDPR_SUBJECT: {"gdpr"},
        }
        required = CERT_MAP.get(requirement, set())
        return required.issubset(self.certifications)

Audit logging satisfies compliance documentation requirements. Every request routing decision logs associated privacy considerations. Entity detection results record what information the system observed. Backend selection rationales explain why qualified alternatives were rejected. This immutable audit trail demonstrates due diligence during compliance reviews.

Data minimization principles restrict information sharing alongside routing constraints. Sensitive fields get redacted before cloud transmission. Aggregation hides individual request details in metrics. Anonymization supresses identifying information from logging. These supplementary controls reinforce privacy policy enforcement.