Europäischer AI Act: Auswirkungen auf RAG-Systeme

Der AI Act (Verordnung über Künstliche Intelligenz) ist die erste umfassende weltweite KI-Regulierung. Im August 2024 in Kraft getreten, wirkt er sich direkt auf RAG-Systeme aus, die in Europa eingesetzt werden. Dieser Leitfaden hilft Ihnen, Ihre Pflichten zu verstehen und die Konformität zu erreichen.

Voraussetzung: Machen Sie sich mit den Grundlagen des RAG und unserem Leitfaden zur RAG-Sicherheit und -Konformität vertraut, bevor Sie fortfahren.

Was ist der AI Act?

Kontext und Ziele

Der AI Act ist eine europäische Verordnung, die einen harmonisierten Rechtsrahmen für Künstliche Intelligenz schafft. Seine Hauptziele sind:

• Die Grundrechte europäischer Bürger schützen
• Klare Regeln für Entwickler und Betreiber von KI aufstellen
• Innovation fördern und gleichzeitig Risiken begrenzen
• Einen Binnenmarkt für KI-Systeme in Europa schaffen

Anwendungszeitplan

Der Zeitplan wurde durch das „Digital Omnibus" (Einigung im Mai 2026, vom Rat am 29. Juni 2026 angenommen) überarbeitet, das die Pflichten für Hochrisikosysteme verschiebt (Stand: Juli 2026):

Wer ist betroffen?

Der AI Act gilt für:

• Anbieter: Diejenigen, die KI-Systeme entwickeln
• Betreiber: Diejenigen, die KI-Systeme im beruflichen Kontext einsetzen
• Importeure/Händler: Diejenigen, die auf dem europäischen Markt anbieten
• Produkthersteller: Wenn KI in ein Produkt integriert ist

DEVELOPERpython
from enum import Enum
from dataclasses import dataclass
from typing import List, Optional

class AIActRole(Enum):
    """Vom AI Act definierte Rollen."""
    PROVIDER = "anbieter"
    DEPLOYER = "betreiber"
    IMPORTER = "importeur"
    DISTRIBUTOR = "haendler"
    PRODUCT_MANUFACTURER = "produkthersteller"

@dataclass
class Organization:
    """Darstellung einer Organisation im Rahmen des AI Act."""
    name: str
    roles: List[AIActRole]
    location: str
    eu_representative: Optional[str] = None

    def needs_eu_representative(self) -> bool:
        """Prüft, ob ein EU-Vertreter erforderlich ist."""
        # Organisationen außerhalb der EU, die in der EU verkaufen
        return self.location not in EU_COUNTRIES and self._serves_eu_market()

    def primary_obligations(self) -> List[str]:
        """Gibt die Hauptpflichten je nach Rolle zurück."""
        obligations = []

        if AIActRole.PROVIDER in self.roles:
            obligations.extend([
                "Qualitätsmanagementsystem",
                "Konformitätsbewertung",
                "Technische Dokumentation",
                "CE-Kennzeichnung",
                "EU-Konformitätserklärung"
            ])

        if AIActRole.DEPLOYER in self.roles:
            obligations.extend([
                "Nutzung gemäß den Anweisungen",
                "Angemessene menschliche Kontrolle",
                "Überwachung des Systems",
                "Aufbewahrung der Logs",
                "Information der betroffenen Personen"
            ])

        return obligations

Risikoklassifizierung

Der AI Act stuft KI-Systeme in vier Risikokategorien ein:

1. Unannehmbares Risiko (Verboten)

Diese Systeme sind in Europa vollständig verboten:

• Schädliche subliminale Manipulation
• Ausnutzung von Schwachstellen (Alter, Behinderung)
• Soziale Bewertung durch Behörden
• Echtzeit-Gesichtserkennung im öffentlichen Raum (mit Ausnahmen)
• Biometrische Kategorisierung anhand sensibler Daten
• Emotionserkennung am Arbeitsplatz/in der Schule

DEVELOPERpython
class ProhibitedSystemChecker:
    """Prüft, ob ein RAG-System verbotene Praktiken nutzt."""

    PROHIBITED_PRACTICES = {
        "subliminal_manipulation": {
            "description": "Subliminale Techniken zur Verhaltensbeeinflussung",
            "indicators": [
                "versteckte_nachrichten",
                "unbewusste_beeinflussung",
                "aggressive_dark_patterns"
            ]
        },
        "vulnerability_exploitation": {
            "description": "Ausnutzung von Schwachstellen",
            "indicators": [
                "zielgruppe_alter",
                "zielgruppe_behinderung",
                "zielgruppe_wirtschaftliche_situation"
            ]
        },
        "social_scoring": {
            "description": "Generalisierte soziale Bewertung",
            "indicators": [
                "verhaltens_score",
                "trustworthiness_bewertung",
                "buergerklassifizierung"
            ]
        },
        "emotion_recognition_workplace": {
            "description": "Emotionserkennung am Arbeitsplatz",
            "indicators": [
                "gesichtsanalyse_mitarbeiter",
                "stresserkennung_arbeit",
                "emotionale_ueberwachung"
            ]
        }
    }

    def check_system(self, system_config: dict) -> dict:
        """Analysiert ein System, um verbotene Praktiken zu erkennen."""
        violations = []

        for practice_id, practice in self.PROHIBITED_PRACTICES.items():
            for indicator in practice["indicators"]:
                if self._detect_indicator(system_config, indicator):
                    violations.append({
                        "practice": practice_id,
                        "description": practice["description"],
                        "indicator": indicator,
                        "severity": "PROHIBITED"
                    })

        return {
            "is_compliant": len(violations) == 0,
            "violations": violations,
            "recommendation": "VERBOTEN - Nicht bereitstellen" if violations else "OK"
        }

    def _detect_indicator(self, config: dict, indicator: str) -> bool:
        """Erkennt einen Indikator für eine verbotene Praktik."""
        # Implementierung der Erkennung
        # ...
        pass

2. Hohes Risiko

Diese Systeme erfordern eine strenge Konformität vor der Markteinführung:

Betroffene Bereiche:

DEVELOPERpython
from typing import Dict, List, Tuple
from enum import Enum

class RiskLevel(Enum):
    PROHIBITED = "verboten"
    HIGH = "hoch"
    LIMITED = "begrenzt"
    MINIMAL = "minimal"

class RAGRiskClassifier:
    """Klassifiziert die Risikostufe eines RAG-Systems gemäß dem AI Act."""

    HIGH_RISK_DOMAINS = {
        "biometric_identification": {
            "keywords": ["gesichtserkennung", "biometrie", "identifikation"],
            "threshold": 0.8
        },
        "critical_infrastructure": {
            "keywords": ["energie", "verkehr", "wasser", "infrastruktur"],
            "threshold": 0.7
        },
        "education": {
            "keywords": ["zulassung", "benotung", "pruefung", "schulbewertung"],
            "threshold": 0.7
        },
        "employment": {
            "keywords": ["rekrutierung", "lebenslauf", "bewerbung", "einstellung", "personal"],
            "threshold": 0.8
        },
        "essential_services": {
            "keywords": ["kredit", "darlehen", "versicherung", "beihilfe", "sozialhilfe"],
            "threshold": 0.8
        },
        "law_enforcement": {
            "keywords": ["polizei", "kriminalitaet", "risiko", "profiling"],
            "threshold": 0.9
        },
        "migration": {
            "keywords": ["visum", "asyl", "grenze", "einwanderung"],
            "threshold": 0.9
        },
        "justice": {
            "keywords": ["gericht", "urteil", "strafe", "rueckfaelligkeit"],
            "threshold": 0.9
        }
    }

    def classify_rag_system(
        self,
        system_description: str,
        use_cases: List[str],
        data_types: List[str],
        decision_impact: str
    ) -> Dict:
        """Klassifiziert ein RAG-System gemäß dem AI Act."""

        # Zuerst verbotene Praktiken prüfen
        prohibited_check = ProhibitedSystemChecker().check_system({
            "description": system_description,
            "use_cases": use_cases
        })

        if not prohibited_check["is_compliant"]:
            return {
                "risk_level": RiskLevel.PROHIBITED,
                "violations": prohibited_check["violations"],
                "can_deploy": False,
                "reason": "Verbotene Praktiken erkannt"
            }

        # Prüfen, ob hohes Risiko
        high_risk_matches = self._check_high_risk_domains(
            system_description,
            use_cases
        )

        if high_risk_matches:
            return {
                "risk_level": RiskLevel.HIGH,
                "matched_domains": high_risk_matches,
                "can_deploy": True,
                "requirements": self._get_high_risk_requirements(),
                "reason": f"Hochrisikobereich(e): {', '.join(high_risk_matches)}"
            }

        # Prüfen, ob begrenztes Risiko (Transparenz erforderlich)
        if self._is_limited_risk(use_cases, data_types):
            return {
                "risk_level": RiskLevel.LIMITED,
                "can_deploy": True,
                "requirements": ["Transparenzpflicht"],
                "reason": "Direkte Interaktion mit Nutzern"
            }

        # Standardmäßig: minimales Risiko
        return {
            "risk_level": RiskLevel.MINIMAL,
            "can_deploy": True,
            "requirements": [],
            "reason": "Kein sensibler Bereich identifiziert"
        }

    def _check_high_risk_domains(
        self,
        description: str,
        use_cases: List[str]
    ) -> List[str]:
        """Identifiziert die Hochrisikobereiche."""
        combined_text = f"{description} {' '.join(use_cases)}".lower()
        matched = []

        for domain, config in self.HIGH_RISK_DOMAINS.items():
            score = sum(
                1 for kw in config["keywords"]
                if kw.lower() in combined_text
            ) / len(config["keywords"])

            if score >= config["threshold"]:
                matched.append(domain)

        return matched

    def _get_high_risk_requirements(self) -> List[str]:
        """Gibt die Anforderungen für Hochrisikosysteme zurück."""
        return [
            "Risikomanagementsystem",
            "Datengovernance",
            "Technische Dokumentation",
            "Führung von Aufzeichnungen (Logs)",
            "Transparenz und Information",
            "Menschliche Kontrolle",
            "Genauigkeit, Robustheit, Cybersicherheit",
            "Konformitätsbewertung",
            "CE-Konformitätserklärung",
            "Registrierung in der EU-Datenbank"
        ]

3. Begrenztes Risiko

Diese Systeme haben ausschließlich Transparenzpflichten:

• Chatbots und KI-Assistenten (einschließlich RAG)
• Content-Generierungssysteme
• Deep Fakes und synthetische Inhalte
• Emotionserkennungssysteme

DEVELOPERpython
class TransparencyRequirements:
    """Transparenzanforderungen für Systeme mit begrenztem Risiko."""

    def generate_disclosure(self, system_type: str) -> str:
        """Erzeugt den erforderlichen Offenlegungstext."""

        disclosures = {
            "chatbot": """
                Sie interagieren mit einem System der künstlichen Intelligenz.
                Dieser Chatbot nutzt die RAG-Technologie (Retrieval-Augmented Generation),
                um seine Antworten aus einer Wissensdatenbank zu generieren.

                Die Antworten werden automatisch generiert und können
                Ungenauigkeiten enthalten. Konsultieren Sie bei wichtigen
                Entscheidungen bitte einen menschlichen Experten.
            """,

            "content_generation": """
                Dieser Inhalt wurde durch künstliche Intelligenz erstellt oder unterstützt.
                Er kann Fehler oder veraltete Informationen enthalten.
                Überprüfen Sie wichtige Informationen anhand von Primärquellen.
            """,

            "emotion_detection": """
                Dieses System nutzt künstliche Intelligenz, um bestimmte
                Aspekte Ihrer Kommunikation zu analysieren. Sie haben das Recht,
                diese Analyse abzulehnen.
            """
        }

        return disclosures.get(system_type, disclosures["chatbot"])

    def get_required_disclosures(self, system_config: dict) -> List[dict]:
        """Gibt alle erforderlichen Offenlegungen zurück."""
        disclosures = []

        # Offenlegung, dass es sich um eine KI handelt
        if system_config.get("user_interaction"):
            disclosures.append({
                "type": "ai_interaction",
                "when": "Vor der ersten Interaktion",
                "content": self.generate_disclosure("chatbot"),
                "format": ["sichtbarer_text", "audio_falls_sprachbasiert"]
            })

        # Offenlegung von generiertem Inhalt
        if system_config.get("generates_content"):
            disclosures.append({
                "type": "generated_content",
                "when": "Bei jedem generierten Inhalt",
                "content": self.generate_disclosure("content_generation"),
                "format": ["wasserzeichen", "metadaten", "sichtbarer_hinweis"]
            })

        return disclosures

4. Minimales Risiko

Keine spezifischen Pflichten, aber empfohlene Best Practices:

• Anti-Spam-Filter
• Videospiele mit KI
• Einfache Empfehlungssysteme

Wo stehen RAG-Systeme?

Allgemeiner Fall: Begrenztes Risiko

Die meisten RAG-Chatbots fallen in die Kategorie begrenztes Risiko:

DEVELOPERpython
def classify_typical_rag_chatbot() -> dict:
    """Klassifizierung eines Standard-RAG-Chatbots."""

    classifier = RAGRiskClassifier()

    # Kundensupport-Chatbot für E-Commerce
    result = classifier.classify_rag_system(
        system_description="Kundensupport-Chatbot für eine E-Commerce-Website",
        use_cases=[
            "Fragen zu Produkten beantworten",
            "Beim Bestellstatus helfen",
            "Rückgabebedingungen erklären"
        ],
        data_types=["produktkatalog", "FAQ", "allgemeine_geschaeftsbedingungen"],
        decision_impact="gering"  # Keine wesentliche Entscheidung
    )

    return result
    # Erwartetes Ergebnis:
    # {
    #     "risk_level": RiskLevel.LIMITED,
    #     "can_deploy": True,
    #     "requirements": ["Transparenzpflicht"],
    #     "reason": "Direkte Interaktion mit Nutzern"
    # }

Hochrisiko-Fall: RAG in HR oder Finanzwesen

Bestimmte RAG-Deployments können hohes Risiko darstellen:

DEVELOPERpython
def classify_hr_rag_system() -> dict:
    """Klassifizierung eines RAG-Systems für die Rekrutierung."""

    classifier = RAGRiskClassifier()

    # System zur Unterstützung der Rekrutierung
    result = classifier.classify_rag_system(
        system_description="RAG-System zur Analyse und Vorauswahl von Lebensläufen",
        use_cases=[
            "Lebensläufe der Bewerber analysieren",
            "Bewerbungen einstufen",
            "Die besten Profile vorschlagen",
            "Interviewfragen generieren"
        ],
        data_types=["lebenslaeufe", "stellenbeschreibungen", "rekrutierungshistorie"],
        decision_impact="hoch"  # Beeinflusst die Einstellung
    )

    return result
    # Erwartetes Ergebnis:
    # {
    #     "risk_level": RiskLevel.HIGH,
    #     "matched_domains": ["employment"],
    #     "can_deploy": True,
    #     "requirements": [...10 Anforderungen...],
    #     "reason": "Hochrisikobereich(e): employment"
    # }

Pflichten für Hochrisiko-RAG-Systeme

Wenn Ihr RAG-System als Hochrisiko eingestuft wird, sind dies Ihre Pflichten:

1. Risikomanagementsystem

DEVELOPERpython
from datetime import datetime
from typing import Dict, List, Any
import json

class RiskManagementSystem:
    """AI-Act-konformes Risikomanagementsystem."""

    def __init__(self, system_id: str):
        self.system_id = system_id
        self.risk_registry = []
        self.mitigation_measures = []
        self.review_schedule = []

    def identify_risks(self) -> List[Dict[str, Any]]:
        """Identifiziert die Risiken des RAG-Systems."""
        risks = [
            {
                "id": "R001",
                "category": "accuracy",
                "description": "Fehlerhafte Antworten oder Halluzinationen",
                "likelihood": "medium",
                "impact": "high",
                "affected_rights": ["Recht auf korrekte Information"]
            },
            {
                "id": "R002",
                "category": "bias",
                "description": "Verzerrungen in den Trainingsdaten",
                "likelihood": "medium",
                "impact": "high",
                "affected_rights": ["Nichtdiskriminierung"]
            },
            {
                "id": "R003",
                "category": "privacy",
                "description": "Offenlegung personenbezogener Daten",
                "likelihood": "low",
                "impact": "very_high",
                "affected_rights": ["Privatsphäre", "Datenschutz"]
            },
            {
                "id": "R004",
                "category": "security",
                "description": "Bösartige Prompt-Injection",
                "likelihood": "medium",
                "impact": "medium",
                "affected_rights": ["Sicherheit"]
            },
            {
                "id": "R005",
                "category": "transparency",
                "description": "Mangelnde Erklärbarkeit der Antworten",
                "likelihood": "high",
                "impact": "medium",
                "affected_rights": ["Recht auf Erklärung"]
            }
        ]

        self.risk_registry = risks
        return risks

    def define_mitigations(self) -> List[Dict[str, Any]]:
        """Definiert die Minderungsmaßnahmen."""
        mitigations = [
            {
                "risk_id": "R001",
                "measure": "Automatisches Fact-Checking",
                "implementation": "Abgleich der Antworten mit verlässlichen Quellen",
                "status": "implemented",
                "effectiveness": "high"
            },
            {
                "risk_id": "R001",
                "measure": "Systematischer Disclaimer",
                "implementation": "Hinweis auf die Grenzen der KI",
                "status": "implemented",
                "effectiveness": "medium"
            },
            {
                "risk_id": "R002",
                "measure": "Daten-Audit",
                "implementation": "Vierteljährliche Überprüfung potenzieller Verzerrungen",
                "status": "scheduled",
                "effectiveness": "medium"
            },
            {
                "risk_id": "R003",
                "measure": "PII-Filterung",
                "implementation": "Erkennung und Maskierung personenbezogener Daten",
                "status": "implemented",
                "effectiveness": "high"
            },
            {
                "risk_id": "R004",
                "measure": "Validierung der Eingaben",
                "implementation": "Erkennung von Injection-Versuchen",
                "status": "implemented",
                "effectiveness": "high"
            },
            {
                "risk_id": "R005",
                "measure": "Quellenangaben",
                "implementation": "Anzeige der verwendeten Dokumente",
                "status": "implemented",
                "effectiveness": "high"
            }
        ]

        self.mitigation_measures = mitigations
        return mitigations

    def generate_report(self) -> Dict[str, Any]:
        """Erstellt einen Risikomanagementbericht."""
        return {
            "system_id": self.system_id,
            "report_date": datetime.utcnow().isoformat(),
            "total_risks": len(self.risk_registry),
            "risks_by_category": self._count_by_category(),
            "mitigation_coverage": self._calculate_coverage(),
            "residual_risks": self._identify_residual_risks(),
            "next_review": self._get_next_review_date(),
            "certification_status": "pending"
        }

    def _calculate_coverage(self) -> float:
        """Berechnet die Abdeckungsrate der Risiken."""
        covered = len(set(m["risk_id"] for m in self.mitigation_measures))
        total = len(self.risk_registry)
        return covered / total if total > 0 else 0

2. Datengovernance

DEVELOPERpython
class DataGovernanceSystem:
    """Datengovernance-System für AI-Act-konforme RAG-Systeme."""

    def __init__(self):
        self.data_sources = []
        self.quality_checks = []

    def register_data_source(self, source: Dict[str, Any]) -> None:
        """Registriert eine Datenquelle mit den erforderlichen Metadaten."""
        source_record = {
            "id": source["id"],
            "name": source["name"],
            "type": source["type"],  # Dokumente, API, Datenbank

            # Qualitätsinformationen (Artikel 10)
            "quality_assessment": {
                "completeness": source.get("completeness_score"),
                "accuracy": source.get("accuracy_score"),
                "timeliness": source.get("last_updated"),
                "representativeness": source.get("representativeness_score")
            },

            # Rückverfolgbarkeit
            "origin": source.get("origin"),
            "collection_method": source.get("collection_method"),
            "preprocessing": source.get("preprocessing_steps", []),

            # Verzerrungen und Einschränkungen
            "known_biases": source.get("known_biases", []),
            "limitations": source.get("limitations", []),
            "gaps": source.get("data_gaps", []),

            # Konformität
            "legal_basis": source.get("legal_basis"),
            "consent_type": source.get("consent_type"),
            "retention_period": source.get("retention_period")
        }

        self.data_sources.append(source_record)

    def assess_training_data_quality(self) -> Dict[str, Any]:
        """Bewertet die Datenqualität gemäß Artikel 10."""
        assessment = {
            "overall_score": 0,
            "dimensions": {},
            "recommendations": []
        }

        dimensions = {
            "relevance": self._check_relevance(),
            "representativeness": self._check_representativeness(),
            "error_free": self._check_errors(),
            "completeness": self._check_completeness(),
            "statistical_properties": self._check_statistical_properties()
        }

        scores = [d["score"] for d in dimensions.values()]
        assessment["overall_score"] = sum(scores) / len(scores)
        assessment["dimensions"] = dimensions

        # Empfehlungen
        for dim_name, dim_result in dimensions.items():
            if dim_result["score"] < 0.7:
                assessment["recommendations"].append({
                    "dimension": dim_name,
                    "issue": dim_result.get("issues", []),
                    "action": dim_result.get("recommended_action")
                })

        return assessment

    def _check_representativeness(self) -> Dict[str, Any]:
        """Prüft die Repräsentativität der Daten."""
        # Analyse der Datenverteilung
        issues = []
        score = 0.8  # Standardwert

        # Geografische Vielfalt prüfen
        # Zeitliche Vielfalt prüfen
        # Abdeckung der Anwendungsfälle prüfen

        return {
            "score": score,
            "issues": issues,
            "recommended_action": "Datenquellen diversifizieren"
        }

3. Technische Dokumentation

DEVELOPERpython
class TechnicalDocumentation:
    """Erstellt die vom AI Act geforderte technische Dokumentation."""

    def generate_full_documentation(
        self,
        system_config: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Erstellt die vollständige Dokumentation nach Artikel 11."""

        return {
            "metadata": {
                "document_version": "1.0",
                "created_at": datetime.utcnow().isoformat(),
                "system_name": system_config["name"],
                "provider": system_config["provider"]
            },

            # 1. Allgemeine Beschreibung
            "general_description": {
                "intended_purpose": system_config["purpose"],
                "intended_users": system_config["target_users"],
                "geographic_scope": system_config["deployment_regions"],
                "interaction_method": "chatbot_text",
                "version": system_config["version"]
            },

            # 2. Systemelemente
            "system_elements": {
                "architecture": self._describe_architecture(system_config),
                "components": [
                    {
                        "name": "Retrieval Engine",
                        "type": "vector_search",
                        "description": "Semantische Suche in der Dokumentendatenbank"
                    },
                    {
                        "name": "LLM Generator",
                        "type": "language_model",
                        "description": "Generierung kontextualisierter Antworten"
                    },
                    {
                        "name": "Document Store",
                        "type": "database",
                        "description": "Speicherung von Dokumenten und Embeddings"
                    }
                ],
                "external_dependencies": system_config.get("dependencies", [])
            },

            # 3. Entwicklungsprozess
            "development_process": {
                "methodology": "agile_mlops",
                "quality_assurance": self._describe_qa_process(),
                "testing_procedures": self._describe_testing(),
                "validation_metrics": self._list_metrics()
            },

            # 4. Fähigkeiten und Einschränkungen
            "capabilities_limitations": {
                "intended_capabilities": [
                    "Fragen zur Dokumentation beantworten",
                    "Sachliche Informationen bereitstellen",
                    "Verwendete Quellen zitieren"
                ],
                "known_limitations": [
                    "Kein Zugriff auf Echtzeit-Internetinformationen",
                    "Kann Halluzinationen produzieren",
                    "Beschränkt auf das Wissen der Dokumentendatenbank",
                    "Versteht keine Bilder oder Audiodateien"
                ],
                "foreseeable_misuse": [
                    "Nutzung für medizinische Entscheidungen ohne Aufsicht",
                    "Nutzung für endgültige Rechtsberatung",
                    "Erzeugung irreführender Inhalte"
                ]
            },

            # 5. Menschliche Kontrolle
            "human_oversight": {
                "oversight_measures": self._describe_oversight(),
                "intervention_capabilities": [
                    "Notabschaltung des Systems",
                    "Manuelle Korrektur der Antworten",
                    "Überprüfung der Dokumentenquellen"
                ],
                "recommended_competencies": [
                    "Kenntnis des Fachbereichs",
                    "Verständnis der Grenzen der KI",
                    "Schulung zum spezifischen Werkzeug"
                ]
            },

            # 6. Leistungsmetriken
            "performance_metrics": {
                "accuracy_metrics": {
                    "retrieval_precision": 0.85,
                    "retrieval_recall": 0.78,
                    "answer_relevance": 0.82,
                    "faithfulness": 0.90
                },
                "benchmarks_used": ["RAGAS", "custom_evaluation"],
                "test_conditions": self._describe_test_conditions()
            },

            # 7. Cybersicherheit
            "cybersecurity": {
                "security_measures": [
                    "Verschlüsselung der Daten im Ruhezustand (AES-256)",
                    "TLS 1.3 für die Kommunikation",
                    "Multi-Faktor-Authentifizierung",
                    "Unveränderliche Audit-Logs"
                ],
                "vulnerability_assessment": {
                    "last_pentest": "2026-01-15",
                    "critical_vulnerabilities": 0,
                    "remediation_status": "completed"
                }
            }
        }

    def _describe_architecture(self, config: Dict) -> Dict:
        """Beschreibt die Architektur des Systems."""
        return {
            "type": "RAG (Retrieval-Augmented Generation)",
            "diagram_reference": "architecture_diagram_v1.png",
            "data_flow": [
                "1. Empfang der Nutzerfrage",
                "2. Embedding der Frage",
                "3. Suche nach relevanten Dokumenten",
                "4. Aufbau des Kontexts",
                "5. Generierung der Antwort durch das LLM",
                "6. Nachbearbeitung und Quellenangaben",
                "7. Rückgabe der Antwort an den Nutzer"
            ]
        }

4. Aufzeichnungen (Logs)

DEVELOPERpython
import logging
from datetime import datetime
from typing import Dict, Any, Optional
import json
import hashlib

class AIActLogger:
    """Log-System gemäß den Anforderungen des AI Act."""

    def __init__(self, system_id: str, storage_backend):
        self.system_id = system_id
        self.storage = storage_backend
        self.logger = logging.getLogger(f"aiact.{system_id}")

    async def log_interaction(
        self,
        interaction_id: str,
        user_query: str,
        system_response: str,
        retrieved_docs: List[str],
        metadata: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """Protokolliert eine AI-Act-konforme Interaktion."""

        log_entry = {
            # Identifikation
            "log_id": self._generate_log_id(),
            "interaction_id": interaction_id,
            "system_id": self.system_id,
            "timestamp": datetime.utcnow().isoformat(),

            # Eingabedaten (gehasht zur Vertraulichkeit)
            "input": {
                "query_hash": self._hash_content(user_query),
                "query_length": len(user_query),
                "detected_language": self._detect_language(user_query),
                "contains_pii": self._check_pii(user_query)
            },

            # Entscheidungsprozess
            "retrieval": {
                "documents_retrieved": len(retrieved_docs),
                "document_ids": retrieved_docs,
                "retrieval_scores": metadata.get("scores", []),
                "retrieval_time_ms": metadata.get("retrieval_time")
            },

            # Ausgabe
            "output": {
                "response_hash": self._hash_content(system_response),
                "response_length": len(system_response),
                "generation_time_ms": metadata.get("generation_time"),
                "confidence_score": metadata.get("confidence"),
                "sources_cited": metadata.get("citations", [])
            },

            # Technische Metadaten
            "technical": {
                "model_version": metadata.get("model_version"),
                "embedding_model": metadata.get("embedding_model"),
                "temperature": metadata.get("temperature"),
                "max_tokens": metadata.get("max_tokens")
            },

            # Kontrollinformationen
            "oversight": {
                "human_review_required": metadata.get("needs_review", False),
                "flagged_issues": metadata.get("flags", []),
                "automated_checks_passed": metadata.get("checks_passed", True)
            }
        }

        # Log speichern
        await self.storage.store(log_entry)

        # Strukturiertes Log für Monitoring
        self.logger.info(
            "Interaction logged",
            extra={
                "interaction_id": interaction_id,
                "docs_retrieved": len(retrieved_docs),
                "response_time_ms": metadata.get("total_time")
            }
        )

        return log_entry

    async def log_incident(
        self,
        incident_type: str,
        severity: str,
        description: str,
        affected_interactions: List[str] = None
    ) -> Dict[str, Any]:
        """Protokolliert einen Vorfall zur Rückverfolgbarkeit."""

        incident = {
            "incident_id": self._generate_log_id(),
            "system_id": self.system_id,
            "timestamp": datetime.utcnow().isoformat(),
            "type": incident_type,
            "severity": severity,
            "description": description,
            "affected_interactions": affected_interactions or [],
            "status": "open",
            "reported_to_authority": severity == "critical"
        }

        await self.storage.store_incident(incident)

        if severity == "critical":
            self.logger.critical(
                f"Critical incident: {incident_type}",
                extra=incident
            )

        return incident

    def _generate_log_id(self) -> str:
        """Erzeugt eine eindeutige ID für den Log-Eintrag."""
        timestamp = datetime.utcnow().isoformat()
        return hashlib.sha256(
            f"{self.system_id}:{timestamp}:{id(self)}".encode()
        ).hexdigest()[:16]

    def _hash_content(self, content: str) -> str:
        """Hasht den Inhalt für anonymisierte Speicherung."""
        return hashlib.sha256(content.encode()).hexdigest()

Transparenzpflichten für RAG-Chatbots

Auch bei begrenztem Risiko haben RAG-Systeme Transparenzpflichten:

Implementierung der Offenlegung

DEVELOPERtypescript
// components/AIDisclosure.tsx
interface AIDisclosureProps {
  systemName: string;
  capabilities: string[];
  limitations: string[];
  dataUsage: string;
}

export function AIDisclosure({
  systemName,
  capabilities,
  limitations,
  dataUsage
}: AIDisclosureProps) {
  return (
    <div className="bg-blue-50 border border-blue-200 rounded-lg p-4 mb-4">
      <div className="flex items-start gap-3">
        <div className="flex-shrink-0">
          <svg className="w-5 h-5 text-blue-600" /* AI icon */ />
        </div>
        <div className="text-sm">
          <p className="font-medium text-blue-900 mb-2">
            Sie interagieren mit {systemName}, einem KI-Assistenten
          </p>

          <details className="mt-2">
            <summary className="cursor-pointer text-blue-700 hover:text-blue-800">
              Mehr über dieses System erfahren
            </summary>

            <div className="mt-3 space-y-3 text-blue-800">
              <div>
                <h4 className="font-medium">Fähigkeiten</h4>
                <ul className="list-disc ml-4 mt-1">
                  {capabilities.map((cap, i) => (
                    <li key={i}>{cap}</li>
                  ))}
                </ul>
              </div>

              <div>
                <h4 className="font-medium">Einschränkungen</h4>
                <ul className="list-disc ml-4 mt-1">
                  {limitations.map((lim, i) => (
                    <li key={i}>{lim}</li>
                  ))}
                </ul>
              </div>

              <div>
                <h4 className="font-medium">Datennutzung</h4>
                <p>{dataUsage}</p>
              </div>
            </div>
          </details>
        </div>
      </div>
    </div>
  );
}

// Verwendung
<AIDisclosure
  systemName="Ailog-Assistent"
  capabilities={[
    "Fragen zu Ihren Produkten beantworten",
    "Informationen aus der Dokumentation bereitstellen",
    "Verwendete Quellen zitieren"
  ]}
  limitations={[
    "Kann ungenaue Antworten produzieren",
    "Kein Zugriff auf Echtzeitinformationen",
    "Ersetzt keinen menschlichen Berater"
  ]}
  dataUsage="Ihre Nachrichten werden ausschließlich zur Generierung von Antworten verwendet. Sie werden 30 Tage lang gespeichert und anschließend gelöscht."
/>

Checkliste zur AI-Act-Konformität

Für alle RAG-Systeme (begrenztes Risiko)

• Klare Offenlegung, dass der Nutzer mit einer KI interagiert
• Information über Fähigkeiten und Einschränkungen
• Mechanismus zur Kontaktaufnahme mit einem Menschen bei Bedarf
• Kennzeichnung von KI-generierten Inhalten

Für Hochrisiko-RAG-Systeme (zusätzlich)

• Dokumentiertes Risikomanagementsystem
• Datengovernance mit Nachvollziehbarkeit
• Vollständige technische Dokumentation
• Konforme Nutzungsprotokolle
• Implementierte Maßnahmen zur menschlichen Aufsicht
• Robustheits- und Cybersicherheitstests
• Durchgeführte Konformitätsbewertung
• CE-Konformitätserklärung
• Registrierung in der EU-Datenbank
• Post-Deployment-Überwachungsverfahren

Fazit

Der AI Act stellt eine wesentliche Veränderung für in Europa eingesetzte RAG-Systeme dar. Die gute Nachricht: Die meisten RAG-Chatbots werden als begrenztes Risiko eingestuft und haben nur Transparenzpflichten. Wenn Sie jedoch in sensiblen Bereichen tätig sind (HR, Finanzwesen, Gesundheit), müssen Sie die Anforderungen für Hochrisikosysteme erfüllen.

Wichtige Punkte:

1. Klassifizieren Sie Ihr System - Bestimmen Sie Ihre Risikostufe
2. Transparenz ist Pflicht - Informieren Sie immer, dass es sich um eine KI handelt
3. Dokumentieren Sie alles - Führen Sie Aufzeichnungen über Ihre Entscheidungen und Prozesse
4. Bereiten Sie sich frühzeitig vor - Die Transparenzpflichten gelten ab August 2026; die Regeln für Hochrisikosysteme wurden durch das Digital Omnibus auf Dezember 2027 verschoben

Weiterführende Informationen

• DSGVO und KI-Chatbots - Konformität bei personenbezogenen Daten
• Audit Trail RAG - Nachvollziehbarkeit von Anfragen
• Evaluierung von RAG-Systemen - Qualitätsmetriken