Compliance Framework Quickstart Guide

pip install "multimind-sdk[compliance]"

from multimind.compliance import GovernanceConfig, Regulation, PrivacyCompliance
from multimind.compliance.ai_frameworks import AIFrameworkCompliance
from multimind.compliance.data_transfer import DataTransferCompliance
from multimind.compliance.accessibility import AccessibilityCompliance
from multimind.compliance.supply_chain import SupplyChainCompliance
from multimind.compliance.corporate import CorporateCompliance

config = GovernanceConfig(
    organization_id="org_123",
    organization_name="Your Organization",
    dpo_email="dpo@yourorg.com",
    enabled_regulations=[
        Regulation.GDPR,
        Regulation.AI_ACT,
        Regulation.HIPAA
    ]
)

# Initialize privacy compliance
privacy = PrivacyCompliance(config=config)

# Process a data subject access request
async def handle_dsar(user_id: str):
    result = await privacy.process_data_subject_request(
        request_type="access",
        user_id=user_id,
        data_ids=["data_123"]
    )
    return result

# Check retention compliance
async def check_retention():
    issues = await privacy.check_retention_compliance()
    return issues

# Initialize AI compliance
ai_compliance = AIFrameworkCompliance(config=config)

# Assess AI system compliance
async def assess_ai_system(system_id: str):
    result = await ai_compliance.assess_oecd_compliance(
        system_id=system_id,
        system_metadata={"type": "classification"}
    )
    return result

# Initialize data transfer compliance
transfer = DataTransferCompliance(config=config)

# Validate international data transfer
async def validate_transfer(source_country: str, destination_country: str):
    result = await transfer.validate_schrems_ii_compliance(
        transfer_id="transfer_123",
        source_country=source_country,
        destination_country=destination_country,
        data_categories=["personal_data"],
        transfer_mechanism="SCC"
    )
    return result

# Initialize accessibility compliance
accessibility = AccessibilityCompliance(config=config)

# Validate WCAG compliance
async def validate_accessibility(system_id: str):
    result = await accessibility.validate_wcag_compliance(
        assessment_id="wcag_123",
        system_id=system_id,
        version="2.1"
    )
    return result

# Initialize supply chain compliance
supply_chain = SupplyChainCompliance(config=config)

# Assess vendor security
async def assess_vendor(vendor_id: str):
    result = await supply_chain.assess_vendor_security(
        vendor_id=vendor_id,
        vendor_name="Vendor Name",
        assessment_type="SIG"
    )
    return result

# Initialize corporate compliance
corporate = CorporateCompliance(config=config)

# Assess SOX compliance
async def assess_sox(system_id: str):
    result = await corporate.assess_sox_compliance(
        assessment_id="sox_123",
        system_id=system_id,
        fiscal_year="2024"
    )
    return result

from multimind.compliance import RegulatoryWatcher

watcher = RegulatoryWatcher(
    sources=[{"name": "eu-ai-act", "url": "https://example.org/ai-act"}],
    state_path="regwatch_state.json",   # persists last-seen hashes between runs
)
events = await watcher.check()        # HTTP fetch of each source
for e in events:                      # ChangeEvent: name, url, changed, diff, checked_at, previous_hash, current_hash
    if e.changed:
        print(e.name, e.diff)

# Dry run from local copies instead of the network:
events = watcher.check_offline({"eu-ai-act": "local_copy.html"})

from multimind.compliance import AdaptivePrivacy
from multimind.compliance.advanced import DPMechanism

# Adapt epsilon from feedback. Recognised config keys: initial_epsilon (1.0),
# min_epsilon (0.1), max_epsilon (10.0), adaptation_rate (0.1), dp_sensitivity (1.0).
privacy_loop = AdaptivePrivacy(config={"initial_epsilon": 1.0})
# Recognised feedback keys: compliance_score (drives adaptation) and loss.
await privacy_loop.adapt_privacy(feedback={"compliance_score": 0.65})
print(privacy_loop.dp_mechanism.epsilon)   # 0.2: stepped up by adaptation_rate because compliance < 0.7
# Caveat: the walk starts from the internal HomomorphicEncryption stub's
# epsilon (0.1), not from initial_epsilon, so the first step lands near
# min_epsilon regardless of the configured starting value.

# Laplace noise for numeric values / lists of numbers (strings and bools raise NotImplementedError)
noisy = DPMechanism(epsilon=1.0, sensitivity=1.0).privatize(42.0)

from multimind.compliance import ModelWatermarking

watermarking = ModelWatermarking(config={})
info = await watermarking.track_fingerprint(model)
# {"fingerprint": "fingerprint_<sha256>", "timestamp": ..., "model_id": ...}
# The fingerprint hashes the model's type name and repr(); it identifies the
# object, not the weights.

from multimind.compliance.model_training import (
    ComplianceDataset,
    ComplianceTrainer,
    ComplianceMetrics
)

# Initialize compliance trainer
compliance_rules = {
    "bias_threshold": 0.1,
    "privacy_threshold": 0.8,
    "transparency_threshold": 0.8,
    "fairness_threshold": 0.8
}
trainer = ComplianceTrainer(
    model=your_model,
    compliance_rules=compliance_rules,
    training_config={
        "epochs": 10,
        "thresholds": compliance_rules,
        "evaluation_metrics": [
            "bias",
            "privacy",
            "transparency",
            "fairness"
        ]
    }
)

# Wrap your dataset with compliance checks
compliance_dataset = ComplianceDataset(
    base_dataset=your_dataset,
    compliance_rules={
        "privacy_threshold": 0.8,
        "fairness_threshold": 0.8,
        "transparency_threshold": 0.8
    },
    data_categories=["personal_data", "health_data"]
)

# Train model with compliance monitoring
results = await trainer.train(
    train_data=train_loader,
    val_data=val_loader,
    metadata={
        "model_type": "classification",
        "data_categories": ["personal_data", "health_data"],
        "jurisdiction": "EU"
    }
)

# Get compliance evaluation results
evaluation = results["final_evaluation"]
print("Compliance Scores:", evaluation["compliance_scores"])
print("Violations:", evaluation["violations"])
print("Recommendations:", evaluation["recommendations"])

# Save training results and compliance documentation
trainer.save_training_results(
    results=results,
    path="training_results.json"
)