Azure Content Understanding vs. Document Intelligence: Die neue Ära der Dokumentenverarbeitung

Klassische OCR/Document Intelligence:
Text erkennen → Felder verknüpfen → Modell trainieren

Content Understanding:
Schema definieren → Generative AI extrahiert → Fertig

# Document Intelligence Training
1. Dokumente hochladen (min. 5 ähnliche Layouts)
2. Text-zu-Label-Verknüpfungen manuell erstellen
3. Modell trainieren (20-60 Minuten)
4. Bei neuem Layout: Zurück zu Schritt 1

// Schema-Definition (JSON)
{
  "scenario": "document",
  "fieldSchema": {
    "fields": {
      "RECHNUNGSNUMMER": {
        "type": "string",
        "method": "extract",
        "description": "Extrahiere die Rechnungsnummer aus deutschen Rechnungen. Diese steht meist am Anfang des Dokuments und ist mit 'Rechnung Nr.', 'Rg-Nr.' oder 'Invoice' beschriftet."
      },
      "RECHNUNGSDATUM": {
        "type": "string",
        "method": "extract",
        "description": "Extrahiere das Rechnungsdatum im deutschen Format (DD.MM.YYYY oder DD/MM/YYYY). Suche nach Begriffen wie 'Datum', 'Rechnungsdatum' oder 'Date'."
      },
      "BRUTTO_BETRAG": {
        "type": "string",
        "method": "extract",
        "description": "Extrahiere den Brutto-Gesamtbetrag inklusive Mehrwertsteuer. Erkennbar an 'Gesamtbetrag', 'Total', 'Brutto' oder 'inkl. MwSt.'."
      }
    }
  }
}

# Traditioneller Ansatz
Schritt 1: 15-20 CV-Beispiele je Layout sammeln
Schritt 2: Manuell Felder markieren
  - "Berufserfahrung"
  - "Ausbildung"
  - "Kenntnisse"
Schritt 3: Modell trainieren (45 Min)
Schritt 4: Bei neuem CV-Design → Zurück zu Schritt 1

# Probleme:
- Creative CVs werden schlecht erkannt
- Unterschiedliche Sprachen (Deutsch/Englisch) problematisch
- Kosten: 15-25€ pro Training + Zeitaufwand

{
  "fieldSchema": {
    "fields": {
      "BERUFSERFAHRUNG": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "POSITION": {
              "type": "string",
              "description": "Extrahiere die Berufsbezeichnung oder Position aus dem deutschen Lebenslauf. Diese findet sich im Abschnitt 'Berufserfahrung', 'Karriere' oder 'Professional Experience'."
            },
            "UNTERNEHMEN": {
              "type": "string",
              "description": "Extrahiere den Firmennamen für jede Position. Achte auf deutsche Unternehmensformen wie GmbH, AG, KG oder internationale Formen."
            },
            "ZEITRAUM": {
              "type": "string",
              "description": "Extrahiere den Beschäftigungszeitraum im Format MM/YYYY - MM/YYYY oder 'seit MM/YYYY'. Berücksichtige deutsche Datumsformate."
            },
            "TAETIGKEIT": {
              "type": "string",
              "description": "Extrahiere die Aufgabenbeschreibung oder Tätigkeiten in deutscher Sprache. Diese Informationen beschreiben die ausgeübten Funktionen und Verantwortlichkeiten."
            },
            "ORT": {
              "type": "string",
              "description": "Extrahiere den Arbeitsort (Stadt, ggf. Land). Deutsche Städte oder internationale Standorte deutscher Unternehmen."
            }
          }
        },
        "description": "Extrahiere alle Berufserfahrungen aus dem deutschen Lebenslauf, unabhängig vom Layout oder Design."
      }
    }
  }
}

// Content Understanding Schema für deutsche Rechnungen
{
  "DEUTSCHE_RECHNUNG": {
    "type": "object",
    "properties": {
      "RECHNUNGSNUMMER": {
        "description": "Deutsche Rechnungsnummer, oft als 'Rg-Nr.', 'Rechnung Nr.' oder 'RE-' prefixed"
      },
      "LIEFERANT": {
        "description": "Firmenname des Lieferanten inkl. Rechtsform (GmbH, AG, etc.)"
      },
      "STEUERNUMMER": {
        "description": "Deutsche Steuernummer oder USt-IdNr. im Format DE123456789"
      },
      "NETTO_BETRAG": {
        "description": "Nettobetrag vor Mehrwertsteuer, meist als 'Netto', 'zzgl. MwSt.' gekennzeichnet"
      },
      "MWST_BETRAG": {
        "description": "Mehrwertsteuerbetrag, erkennbar an '19% MwSt.' oder '7% MwSt.'"
      },
      "BRUTTO_BETRAG": {
        "description": "Gesamtbetrag inkl. MwSt., als 'Endbetrag', 'Total' oder 'Rechnungsbetrag'"
      },
      "ZAHLUNGSZIEL": {
        "description": "Zahlungsfrist in deutschen Begriffen: 'binnen 14 Tagen', '30 Tage netto', 'sofort fällig'"
      }
    }
  }
}

{
  "PRUEFZERTIFIKAT": {
    "type": "object",
    "properties": {
      "ZERTIFIKATSNUMMER": {
        "description": "Eindeutige Zertifikatsnummer des Prüfinstituts (TÜV, DEKRA, etc.)"
      },
      "PRUEFNORM": {
        "description": "Angewandte Prüfnorm wie ISO 9001, TS 16949, DIN EN standards"
      },
      "GUELTIGKEITSDAUER": {
        "description": "Gültigkeitszeitraum des Zertifikats im deutschen Datumsformat"
      },
      "PRUEFINSTANZ": {
        "description": "Name des Prüfinstituts (TÜV SÜD, TÜV Nord, DEKRA, SGS, etc.)"
      },
      "GEPRUEFTES_PRODUKT": {
        "description": "Bezeichnung des geprüften Produkts oder Systems"
      }
    }
  }
}

{
  "ARBEITSZEUGNIS": {
    "type": "object",
    "properties": {
      "MITARBEITER_NAME": {
        "description": "Vollständiger Name des Mitarbeiters wie im deutschen Arbeitszeugnis"
      },
      "TAETIGKEIT": {
        "description": "Ausgeübte Tätigkeit oder Position im deutschen Unternehmen"
      },
      "BESCHAEFTIGUNGSDAUER": {
        "description": "Zeitraum der Beschäftigung im deutschen Format"
      },
      "BEURTEILUNG": {
        "description": "Leistungsbeurteilung in deutscher Zeugnissprache ('stets zu unserer vollsten Zufriedenheit', etc.)"
      },
      "GRUND_AUSSCHEIDEN": {
        "description": "Grund für das Ausscheiden, falls genannt (eigener Wunsch, betriebsbedingt, etc.)"
      }
    }
  }
}

Jahr 1:
- Setup/Training: 8.000€ (40h á 200€)
- API-Kosten: 6.000€ (50.000 Dokumente)
- Re-Training: 4.000€ (neue Layouts)
Total: 18.000€

Jahr 2-3:
- Wartung: 3.000€/Jahr
- API-Kosten: 6.000€/Jahr
- Re-Training: 2.000€/Jahr
Total: 22.000€

Gesamt 3 Jahre: 40.000€

Jahr 1:
- Setup: 1.000€ (5h á 200€)
- API-Kosten: 3.600€ (50.000 Dokumente)
- Schema-Anpassungen: 500€
Total: 5.100€

Jahr 2-3:
- Wartung: 200€/Jahr
- API-Kosten: 3.600€/Jahr
- Schema-Updates: 200€/Jahr
Total: 8.000€

Gesamt 3 Jahre: 13.100€

# Azure Content Understanding Projekt erstellen
az cognitiveservices account create \
  --name "content-understanding-prod" \
  --resource-group "document-processing-rg" \
  --kind "ContentUnderstanding" \
  --sku "S0" \
  --location "West Europe"

# Key Vault für Secrets
az keyvault create \
  --name "doc-secrets-kv" \
  --resource-group "document-processing-rg" \
  --location "West Europe"

public class GermanDocumentProcessor
{
    private readonly ContentUnderstandingClient _client;
    private readonly string _projectName;

    public GermanDocumentProcessor(string endpoint, string apiKey, string projectName)
    {
        _client = new ContentUnderstandingClient(new Uri(endpoint), new AzureKeyCredential(apiKey));
        _projectName = projectName;
    }

    public async Task<RechnungsDaten> ExtractRechnungAsync(Stream documentStream)
    {
        var operation = await _client.BeginAnalyzeDocumentAsync(
            _projectName,
            documentStream,
            "german-invoice-schema"
        );

        var result = await operation.WaitForCompletionAsync();

        return new RechnungsDaten
        {
            Rechnungsnummer = result.Value.Fields["RECHNUNGSNUMMER"]?.AsString(),
            Lieferant = result.Value.Fields["LIEFERANT"]?.AsString(),
            BruttoGesamt = decimal.Parse(result.Value.Fields["BRUTTO_BETRAG"]?.AsString() ?? "0"),
            Steuernummer = result.Value.Fields["STEUERNUMMER"]?.AsString(),
            // ... weitere Felder
        };
    }
}

public class RechnungsDaten
{
    public string Rechnungsnummer { get; set; }
    public string Lieferant { get; set; }
    public decimal BruttoGesamt { get; set; }
    public string Steuernummer { get; set; }
    public DateTime Rechnungsdatum { get; set; }
}

from azure.ai.contentunderstanding import ContentUnderstandingClient
from azure.core.credentials import AzureKeyCredential
import json

class DeutschesDokumentProcessing:
    def __init__(self, endpoint: str, api_key: str):
        self.client = ContentUnderstandingClient(
            endpoint=endpoint,
            credential=AzureKeyCredential(api_key)
        )

    def extract_rechnung(self, document_path: str) -> dict:
        """Extrahiert Daten aus deutschen Rechnungen"""

        with open(document_path, 'rb') as doc:
            operation = self.client.begin_analyze_document(
                project_name="deutsche-rechnungen",
                document=doc,
                schema_name="rechnung-schema"
            )

        result = operation.result()

        return {
            'rechnungsnummer': result.fields.get('RECHNUNGSNUMMER', {}).get('content'),
            'lieferant': result.fields.get('LIEFERANT', {}).get('content'),
            'brutto_betrag': result.fields.get('BRUTTO_BETRAG', {}).get('content'),
            'mwst_betrag': result.fields.get('MWST_BETRAG', {}).get('content'),
            'zahlungsziel': result.fields.get('ZAHLUNGSZIEL', {}).get('content'),
            'confidence_score': result.confidence
        }

    def extract_bewerbung(self, cv_path: str) -> dict:
        """Extrahiert Daten aus deutschen Lebensläufen"""

        with open(cv_path, 'rb') as doc:
            operation = self.client.begin_analyze_document(
                project_name="deutsche-bewerbungen",
                document=doc,
                schema_name="lebenslauf-schema"
            )

        result = operation.result()

        berufserfahrung = []
        if 'BERUFSERFAHRUNG' in result.fields:
            for job in result.fields['BERUFSERFAHRUNG'].get('items', []):
                berufserfahrung.append({
                    'position': job.get('POSITION', {}).get('content'),
                    'unternehmen': job.get('UNTERNEHMEN', {}).get('content'),
                    'zeitraum': job.get('ZEITRAUM', {}).get('content'),
                    'ort': job.get('ORT', {}).get('content')
                })

        return {
            'berufserfahrung': berufserfahrung,
            'confidence_score': result.confidence
        }

# Hybrid-Ansatz für Produktiveinsatz
def robust_document_extraction(document_path: str):
    try:
        # Primär: Content Understanding
        result = content_understanding_client.extract(document_path)
        if result.confidence > 0.8:
            return result
    except Exception as e:
        logger.warning(f"Content Understanding failed: {e}")

    # Fallback: Document Intelligence
    return document_intelligence_client.extract(document_path)

# Kostenmonitoring implementieren
def estimate_monthly_costs(documents_per_month: int, avg_pages_per_doc: int):
    total_pages = documents_per_month * avg_pages_per_doc
    cost_per_1000_pages = 1.50  # Preview pricing

    monthly_cost = (total_pages / 1000) * cost_per_1000_pages
    return monthly_cost

# Beispiel: 10.000 Dokumente, 2 Seiten durchschnittlich
print(f"Monatliche Kosten: {estimate_monthly_costs(10000, 2)}€")
# Output: 30€/Monat

// Data Residency Settings
{
  "processing_location": "West Europe",
  "data_retention": "30_days",
  "personal_data_handling": "pseudonymized",
  "audit_logging": "enabled"
}

Deutsche Besonderheiten erfolgreich erkannt:
✅ Umlaute (ä, ö, ü, ß)
✅ Deutsche Datumsformate (DD.MM.YYYY)
✅ Währungsformate (1.234,56 €)
✅ Rechtsformen (GmbH, AG, KG, e.V.)
✅ Steuernummern (DE123456789)
✅ Deutsche Anreden (Sehr geehrte Damen und Herren)

Herausforderungen:
⚠️ Handschriftliche Notizen
⚠️ Sehr alte Dokumente (schwache Scan-Qualität)
⚠️ Komplexe Tabellen mit Zeilenzusammenfassungen

# Phase 1: Parallel-Betrieb (4 Wochen)
class HybridDocumentProcessor:
    def __init__(self):
        self.di_client = DocumentIntelligenceClient(...)
        self.cu_client = ContentUnderstandingClient(...)

    def process_document(self, document: bytes) -> dict:
        # Beide Services parallel testen
        di_result = self.di_client.extract(document)
        cu_result = self.cu_client.extract(document)

        # Qualitätsvergleich loggen
        self.log_comparison(di_result, cu_result)

        # Content Understanding bevorzugen bei hoher Confidence
        if cu_result.confidence > 0.85:
            return cu_result.to_dict()
        else:
            return di_result.to_dict()

# Phase 2: Schrittweise Umstellung (2-4 Wochen)
# Phase 3: Vollständige Migration (1 Woche)

def convert_di_labels_to_cu_schema(di_model_labels: list) -> dict:
    """Konvertiert Document Intelligence Labels zu Content Understanding Schema"""

    schema = {
        "scenario": "document",
        "fieldSchema": {
            "fields": {}
        }
    }

    for label in di_model_labels:
        schema["fieldSchema"]["fields"][label.name] = {
            "type": label.type or "string",
            "method": "extract",
            "description": f"Extrahiere {label.description} aus dem deutschen Dokument."
        }

    return schema