Namespace-Technologie fuer Geschaeftskunden

SCHRITT 1: DOKUMENTE ERFASSEN & PSEUDONYMISIEREN
SDK empfaengt Dokumente (PDF, Bild, Text)
  → Personenbezogene Daten werden erkannt (Header, Namen, IDs)
  → PII wird durch zufaellige Tokens ersetzt (doc_token, UUID4)
  → Zuordnung "Token → Originalname" wird lokal gesichert

SCHRITT 2: CLIENT-SEITIGE VERSCHLUESSELUNG
Kunde konfiguriert eine Passphrase im SDK
  → SDK leitet daraus einen 256-Bit-Schluessel ab (PBKDF2, 100k Runden)
  → Dokumente werden mit AES-256-GCM verschluesselt
  → Nur der Hash des Schluessels wird an den Server gesendet

SCHRITT 3: IDENTITAETS-MAP SICHERN
  → Nur mit der Passphrase des Kunden rekonstruierbar

SCHRITT 4: UPLOAD IN DEN KUNDEN-NAMESPACE
  → Jeder Kunde hat eine eigene tenant_id
  → Daten werden in MinIO (Storage) + Qdrant (Vektoren) gespeichert

SCHRITT 5: KI-VERARBEITUNG IN DER CLOUD
  → RAG-System durchsucht Referenzdokumente des Kunden
  → KI generiert Ergebnisse basierend auf Kundenkontext

SCHRITT 6: ERGEBNISSE ZURUECK
  → SDK entschluesselt die Ergebnisse mit der Passphrase

SCHRITT 7: RE-IDENTIFIZIERUNG & FINALISIERUNG
  → Identitaets-Map wird entschluesselt
  → Tokens werden wieder den echten Datensaetzen zugeordnet

import { BreakpilotSDK, NamespaceClient } from '@breakpilot/compliance-sdk'

// 1. SDK initialisieren mit API-Key
const sdk = new BreakpilotSDK({
  apiKey: process.env.BREAKPILOT_API_KEY,
  endpoint: 'https://api.breakpilot.de'
})

// 2. Namespace-Client erstellen (pro Mandant/Abteilung)
const namespace = sdk.createNamespace({
  tenantId: 'kunde-firma-abc',
  passphrase: process.env.ENCRYPTION_PASSPHRASE  // Bleibt lokal!
})

// 3. Dokument pseudonymisieren & verschluesselt hochladen
const result = await namespace.upload({
  file: documentBuffer,
  metadata: { type: 'vertrag', category: 'due-diligence' },
  pseudonymize: true,
  headerRedaction: true
})
// result.docToken = "a7f3c2d1-4e9b-4a5f-8c7d-..."

// 4. Referenzdokument hochladen (z.B. Pruefkriterien)
await namespace.uploadReference({
  file: referenceBuffer,
  title: 'Pruefkriterien Vertrag Typ A'
})

// 5. KI-Verarbeitung anstossen
const analysis = await namespace.analyze({
  docToken: result.docToken,
  prompt: 'Pruefe den Vertrag gegen die Referenzkriterien',
  useRAG: true
})

// 6. Ergebnisse entschluesseln (passiert automatisch im SDK)
console.log(analysis.findings)
console.log(analysis.score)

// 7. Re-Identifizierung (Token → Originalname)
const identityMap = await namespace.getIdentityMap()
const originalName = identityMap[result.docToken]

NamespaceSession
├── tenant_id                = "kunde-firma-abc"      ← Pflichtfeld (Isolation)
├── encrypted_identity_map   = [verschluesselte Bytes]  ← Nur mit Passphrase lesbar
├── identity_map_iv          = "a3f2c1..."
│
└── PseudonymizedDocument (pro Dokument)
    ├── doc_token             = "a7f3c2d1-..."         ← Zufaelliger Token (Primary Key)
    ├── session_id            = [Referenz]
    └── (Kein Name, keine personenbezogenen Daten)

┌─────────────────────────────────────────────────────────────────┐
│                    System des Kunden (SDK)                       │
├─────────────────────────────────────────────────────────────────┤
│  1. Kunde konfiguriert Passphrase im SDK                        │
│     → Passphrase bleibt hier -- wird NIE gesendet               │
│                                                                 │
│  2. Schluessel-Ableitung:                                       │
│     PBKDF2-SHA256(Passphrase, zufaelliger Salt, 100.000 Runden) │
│     → Ergebnis: 256-Bit-Schluessel (32 Bytes)                   │
│                                                                 │
│  3. Verschluesselung:                                           │
│     AES-256-GCM(Schluessel, zufaelliger IV, Dokument)           │
│     → GCM: Garantiert Integritaet (Manipulation erkennbar)      │
│                                                                 │
│  4. Schluessel-Hash:                                            │
│     SHA-256(abgeleiteter Schluessel) → Hash fuer Verifikation   │
│     → Vom Hash kann der Schluessel NICHT zurueckberechnet werden│
│                                                                 │
│  5. Upload: Nur diese Daten gehen an den Cloud-Server:          │
│     • Verschluesselter Blob   • Salt   • IV   • Schluessel-Hash │
│                                                                 │
│     Was NICHT an den Server geht:                               │
│     ✗ Passphrase  ✗ Abgeleiteter Schluessel  ✗ Klartext         │
└─────────────────────────────────────────────────────────────────┘

Kunde A (tenant_id: "firma-alpha-001")
├── Dokument 1 (verschluesselt)
└── Referenz: Pruefkriterien 2025

Kunde B (tenant_id: "firma-beta-002")
└── Referenz: Compliance-Vorgaben 2025

Suchanfrage von Kunde A:
  → Suche NUR in tenant_id = "firma-alpha-001"
  → Kunde B's Daten sind UNSICHTBAR

Jede Qdrant-Query hat diesen Pflichtfilter:
  must_conditions = [
    FieldCondition(key="tenant_id", match="firma-alpha-001")
  ]

Referenzdokument (verschluesselt auf Server)
     |
     v
┌────────────────────────────────────┐
│  1. Passphrase-Verifikation        │  ← SDK sendet Schluessel-Hash
└──────────┬─────────────────────────┘
           v
┌────────────────────────────────────┐
│  2. Entschluesselung               │  ← Temporaer im Arbeitsspeicher
└──────────┬─────────────────────────┘
           v
┌────────────────────────────────────┐
│  3. Text-Extraktion                │  ← PDF → Klartext
└──────────┬─────────────────────────┘
           v
┌────────────────────────────────────┐
│  4. Chunking                       │  ← ~1.000-Zeichen-Abschnitte
└──────────┬─────────────────────────┘
           v
┌────────────────────────────────────┐
│  5. Embedding                      │  ← Text → 1.536 Zahlen
└──────────┬─────────────────────────┘
           v
┌────────────────────────────────────┐
│  6. Re-Encryption                  │  ← Jeder Chunk wird erneut verschluesselt
└──────────┬─────────────────────────┘
           v
┌────────────────────────────────────┐
│  7. Qdrant-Indexierung              │  ← Vektor + verschluesselter Chunk
│  tenant_id: "firma-alpha-001"      │     mit Tenant-Filter gespeichert
│  training_allowed: false           │
└────────────────────────────────────┘

Eigentuemer                        Server                     Eingeladener
     │                                │                             │
     │  1. Einladung senden            │                             │
     │─────────────────────────────────▶                             │
     │                                │  2. Einladung erstellt       │
     │                                │     (14 Tage gueltig)        │
     │                                │  3. Benachrichtigung ──────▶│
     │                                │                 4. Einladung annehmen
     │                                │◀─────────────────────────────│
     │                                │  5. Key-Share erstellt       │
     │                                │  6. Eingeladener kann ──────▶│
     │                                │     Daten im Namespace        │
     │                                │     abfragen                 │
     │  7. Zugriff widerrufen          │                             │
     │─────────────────────────────────▶  Share deaktiviert          │