AI Labs Playbook

How AI labs use SOVEREIGN\PROVENANCE for dataset provenance and synthetic output registration

Overview

AI labs must track dataset provenance, register synthetic outputs, and comply with creator rights. SOVEREIGN\PROVENANCE provides the infrastructure.

Dataset Provenance

Register Training Dataset

import { createSovProvClient } from '@sovprovenance/sdk-js';

const client = createSovProvClient({
  baseUrl: 'https://api.sovereign.provenance',
  apiKey: 'your-lab-api-key',
});

// For each source in your dataset
for (const source of datasetSources) {
  // Check if source has passport
  const passport = await client.getPassport(source.passportId);
  
  // Evaluate rights for AI training
  const evaluation = await client.evaluateUse(passport.accordId, {
    type: 'ai_training',
    commercial: false,
  });

  if (!evaluation.allowed) {
    console.warn(`Cannot use ${source.passportId}: ${evaluation.reason}`);
    continue;
  }

  // Record dataset usage
  await client.writeEvent({
    type: 'dataset_registered',
    identity: labIdentity.id,
    payload: {
      datasetId: datasetId,
      sourcePassportId: source.passportId,
      evaluation: evaluation,
    },
  });
}

Track Dataset Lineage

// Get all sources used in training
const datasetEvents = await client.listEvents({
  type: 'dataset_registered',
  identity: labIdentity.id,
});

// Build lineage tree
const lineage = await client.getLineage(datasetId);

Synthetic Output Registration

Register Synthetic Output

// After generating synthetic content
const synthetic = await client.registerSynthetic({
  artifactId: generatedContentId,
  modelId: 'your-model-v1',
  modelVersion: '1.0.0',
  declaredAt: new Date().toISOString(),
  confidence: 0.95, // How confident you are it's synthetic
});

// Create passport for synthetic output
const syntheticPassport = await client.createPassport({
  identityId: labIdentity.id,
  sealId: syntheticSeal.id,
  metadata: {
    artifactType: 'image',
    title: 'Synthetic Output',
    tags: ['synthetic', 'ai-generated'],
  },
});

// Link to source dataset
await client.writeEvent({
  type: 'synthetic_registered',
  identity: labIdentity.id,
  payload: {
    syntheticPassportId: syntheticPassport.id,
    sourceDatasetId: datasetId,
    modelId: 'your-model-v1',
  },
});

Compliance Workflow

Pre-Training Compliance Check

async function checkTrainingCompliance(sources: string[]) {
  const results = [];
  
  for (const passportId of sources) {
    const passport = await client.getPassport(passportId);
    const accord = await client.getAccord(passport.accordId);
    
    const evaluation = await client.evaluateUse(accord.id, {
      type: 'ai_training',
      commercial: false,
    });

    results.push({
      passportId,
      allowed: evaluation.allowed,
      reason: evaluation.reason,
    });
  }

  const allowed = results.filter(r => r.allowed);
  const denied = results.filter(r => !r.allowed);

  return {
    total: results.length,
    allowed: allowed.length,
    denied: denied.length,
    details: results,
  };
}

Training Compliance Report

// Generate compliance report
const report = {
  datasetId: datasetId,
  totalSources: 1000,
  compliantSources: 950,
  nonCompliantSources: 50,
  complianceRate: 0.95,
  details: complianceResults,
};

// Store in ledger
await client.writeEvent({
  type: 'compliance_report',
  identity: labIdentity.id,
  payload: report,
});

Best Practices

Check Before Training - Evaluate rights before using content
Register Everything - Register all synthetic outputs
Maintain Lineage - Track which sources were used
Document Models - Include model ID and version
Compliance Reports - Generate regular compliance reports

Integration Examples

Training Pipeline Integration

from sovprovenance import SovProvClient

client = SovProvClient(
    base_url="https://api.sovereign.provenance",
    api_key="your-api-key"
)

def check_source_compliance(passport_id):
    passport = client.get_passport(passport_id)
    accord = client.get_accord(passport.accord_id)
    
    evaluation = client.evaluate_use(accord.id, {
        "type": "ai_training",
        "commercial": False
    })
    
    return evaluation.allowed

# Use in training pipeline
for source in training_sources:
    if not check_source_compliance(source.passport_id):
        print(f"Skipping {source.passport_id}: not compliant")
        continue
    # Proceed with training