DSGVO und KI-Chatbots : Vollständiger Compliance-Leitfaden

Der Einsatz eines KI-Chatbots stellt besondere Herausforderungen beim Schutz personenbezogener Daten dar. Dieser Leitfaden begleitet Sie bei der DSGVO-Konformität Ihres Konversationsassistenten — von der Einholung der Einwilligung bis zur Verwaltung der Rechte der betroffenen Personen.

Voraussetzungen : Bevor Sie in diesen Leitfaden eintauchen, stellen Sie sicher, dass Sie die Fondamentaux du RAG beherrschen und unseren übergeordneten Leitfaden zur Sécurité et conformité RAG gelesen haben.

Warum die DSGVO für KI-Chatbots gilt

Personenbezogene Daten im Gesprächskontext

Ein KI-Chatbot sammelt und verarbeitet zahlreiche personenbezogene Daten, häufig ohne dass der Nutzer sich dessen vollständig bewusst ist :

Le cas particulier des systèmes RAG

Les systèmes RAG (Retrieval-Augmented Generation) ajoutent une couche de complexité. Non seulement ils collectent les données de conversation, mais ils peuvent également :

• Stocker les embeddings des requêtes utilisateur
• Conserver l'historique des sessions pour améliorer la pertinence
• Indexer des documents contenant des données personnelles
• Générer des réponses basées sur des données personnelles tierces

Die 7 DSGVO-Prinzipien angewendet auf Chatbots

1. Rechtmäßigkeit, Fairness und Transparenz

Ihr Chatbot muss die Nutzer klar über die Erhebung ihrer Daten informieren.

DEVELOPERpython
from dataclasses import dataclass
from typing import Optional
from datetime import datetime

@dataclass
class ConsentRecord:
    """Aufzeichnung der Nutzerzustimmung."""
    user_id: str
    consent_given: bool
    consent_timestamp: datetime
    consent_version: str
    ip_address: str
    purpose: str

class ConsentManager:
    """DSGVO-Zustimmungsmanager für Chatbot."""

    CONSENT_TEXT = """
    En utilisant ce chatbot, vous acceptez que nous collections
    et traitions vos messages pour vous fournir des réponses
    pertinentes. Vos données sont conservées pendant 12 mois
    et ne sont jamais partagées avec des tiers.

    Vous pouvez retirer votre consentement à tout moment
    en tapant /supprimer-mes-donnees.
    """

    def __init__(self, db_connection):
        self.db = db_connection
        self.current_version = "2.1"

    async def check_consent(self, user_id: str) -> bool:
        """Prüft, ob der Nutzer seine Zustimmung gegeben hat."""
        record = await self.db.get_consent(user_id)
        if not record:
            return False
        # Prüfen, ob die Zustimmung noch gültig ist
        return (
            record.consent_given and
            record.consent_version == self.current_version
        )

    async def request_consent(self, user_id: str, ip_address: str) -> str:
        """Fordert die Zustimmung des Nutzers an."""
        return {
            "type": "consent_request",
            "message": self.CONSENT_TEXT,
            "buttons": [
                {"text": "J'accepte", "action": "consent_accept"},
                {"text": "Je refuse", "action": "consent_decline"},
                {"text": "En savoir plus", "action": "privacy_policy"}
            ]
        }

    async def record_consent(
        self,
        user_id: str,
        consent_given: bool,
        ip_address: str,
        purpose: str = "chatbot_interaction"
    ) -> ConsentRecord:
        """Speichert die Zustimmung des Nutzers."""
        record = ConsentRecord(
            user_id=user_id,
            consent_given=consent_given,
            consent_timestamp=datetime.utcnow(),
            consent_version=self.current_version,
            ip_address=ip_address,
            purpose=purpose
        )
        await self.db.save_consent(record)
        return record

2. Zweckbindung

Definieren Sie klar, warum Sie Daten erheben, und verwenden Sie sie nicht für andere Zwecke.

DEVELOPERpython
from enum import Enum
from typing import List, Set

class DataPurpose(Enum):
    """Erlaubte Verarbeitungszwecke für Daten."""
    RESPONSE_GENERATION = "generation_reponse"
    CONVERSATION_CONTEXT = "contexte_conversation"
    SERVICE_IMPROVEMENT = "amelioration_service"
    ANALYTICS = "statistiques_agregees"
    SUPPORT = "support_client"

class PurposeLimiter:
    """Begrenzt die Datennutzung auf die deklarierten Zwecke."""

    def __init__(self):
        # Zuordnung données -> finalités autorisées
        self.allowed_purposes = {
            "message_content": {
                DataPurpose.RESPONSE_GENERATION,
                DataPurpose.CONVERSATION_CONTEXT
            },
            "user_preferences": {
                DataPurpose.RESPONSE_GENERATION,
                DataPurpose.SERVICE_IMPROVEMENT
            },
            "conversation_history": {
                DataPurpose.CONVERSATION_CONTEXT,
                DataPurpose.SUPPORT
            },
            "usage_metrics": {
                DataPurpose.ANALYTICS,
                DataPurpose.SERVICE_IMPROVEMENT
            }
        }

    def can_use_data(
        self,
        data_type: str,
        intended_purpose: DataPurpose
    ) -> bool:
        """Prüft, ob die Nutzung erlaubt ist."""
        allowed = self.allowed_purposes.get(data_type, set())
        return intended_purpose in allowed

    def get_allowed_purposes(self, data_type: str) -> Set[DataPurpose]:
        """Gibt die erlaubten Zwecke für einen Datentyp zurück."""
        return self.allowed_purposes.get(data_type, set())

    def validate_processing(
        self,
        data_types: List[str],
        purpose: DataPurpose
    ) -> dict:
        """Validiert eine Verarbeitung vor ihrer Ausführung."""
        results = {}
        for data_type in data_types:
            results[data_type] = self.can_use_data(data_type, purpose)

        all_valid = all(results.values())
        return {
            "valid": all_valid,
            "details": results,
            "purpose": purpose.value,
            "blocked_data": [k for k, v in results.items() if not v]
        }

3. Datenminimierung

Sammeln Sie nur die Daten, die für den Betrieb des Chatbots strikt notwendig sind.

DEVELOPERpython
import re
from typing import Dict, Any, List
import hashlib

class DataMinimizer:
    """Minimiert die vom Chatbot gesammelten Daten."""

    # Muster für Daten, die nicht gespeichert werden sollen
    SENSITIVE_PATTERNS = {
        "credit_card": r"\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b",
        "ssn_fr": r"\b[12]\s?\d{2}\s?\d{2}\s?\d{2}\s?\d{3}\s?\d{3}\s?\d{2}\b",
        "phone": r"\b(?:\+33|0)\s?[1-9](?:[\s.-]?\d{2}){4}\b",
        "email": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",
        "iban": r"\b[A-Z]{2}\d{2}(?:\s?\d{4}){4,7}\b",
    }

    def __init__(self, config: Dict[str, Any] = None):
        self.config = config or {}
        self.redaction_placeholder = "[DONNÉE MASQUÉE]"

    def minimize_message(self, message: str) -> Dict[str, Any]:
        """Minimiert sensible Daten in einer Nachricht."""
        minimized = message
        detected_types = []

        for data_type, pattern in self.SENSITIVE_PATTERNS.items():
            if re.search(pattern, minimized, re.IGNORECASE):
                detected_types.append(data_type)
                minimized = re.sub(
                    pattern,
                    self.redaction_placeholder,
                    minimized,
                    flags=re.IGNORECASE
                )

        return {
            "original_length": len(message),
            "minimized_message": minimized,
            "detected_sensitive_data": detected_types,
            "was_modified": len(detected_types) > 0
        }

    def minimize_conversation(
        self,
        messages: List[Dict[str, Any]]
    ) -> List[Dict[str, Any]]:
        """Minimiert eine gesamte Konversation."""
        minimized_messages = []

        for msg in messages:
            result = self.minimize_message(msg.get("content", ""))
            minimized_messages.append({
                **msg,
                "content": result["minimized_message"],
                "_minimization_applied": result["was_modified"]
            })

        return minimized_messages

    def pseudonymize_user_id(self, user_id: str, salt: str) -> str:
        """Pseudonymisiert eine Nutzerkennung."""
        combined = f"{user_id}:{salt}"
        return hashlib.sha256(combined.encode()).hexdigest()[:16]

4. Genauigkeit der Daten

Daten müssen korrekt und aktuell sein. Für einen Chatbot betrifft das hauptsächlich die RAG-Wissensbasis.

DEVELOPERpython
from datetime import datetime, timedelta
from typing import Optional
import logging

class DataAccuracyChecker:
    """Prüft und erhält die Genauigkeit der RAG-Daten."""

    def __init__(self, vector_store, document_store):
        self.vector_store = vector_store
        self.document_store = document_store
        self.logger = logging.getLogger(__name__)

    async def check_document_freshness(
        self,
        doc_id: str,
        max_age_days: int = 90
    ) -> Dict[str, Any]:
        """Prüft die Aktualität eines indexierten Dokuments."""
        doc = await self.document_store.get(doc_id)
        if not doc:
            return {"status": "not_found", "doc_id": doc_id}

        age = datetime.utcnow() - doc.indexed_at
        is_stale = age > timedelta(days=max_age_days)

        return {
            "doc_id": doc_id,
            "indexed_at": doc.indexed_at.isoformat(),
            "age_days": age.days,
            "is_stale": is_stale,
            "recommendation": "reindex" if is_stale else "ok"
        }

    async def flag_outdated_content(
        self,
        namespace: str,
        max_age_days: int = 90
    ) -> List[str]:
        """Identifiziert veraltete Inhalte zur Aktualisierung."""
        all_docs = await self.document_store.list_by_namespace(namespace)
        outdated = []

        for doc in all_docs:
            check = await self.check_document_freshness(doc.id, max_age_days)
            if check.get("is_stale"):
                outdated.append(doc.id)
                self.logger.warning(
                    f"Document obsolète détecté: {doc.id} "
                    f"(âge: {check['age_days']} jours)"
                )

        return outdated

    async def handle_correction_request(
        self,
        user_id: str,
        correction: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Behandelt eine Anfrage zur Datenberichtigung."""
        # Protokolliere die Anfrage für das Audit
        self.logger.info(
            f"Demande de correction reçue de {user_id}: {correction}"
        )

        # Créer un ticket de révision
        ticket = {
            "type": "data_correction",
            "user_id": user_id,
            "requested_at": datetime.utcnow().isoformat(),
            "correction_details": correction,
            "status": "pending_review"
        }

        return ticket

5. Speicherbegrenzung

Legen Sie klare Aufbewahrungsfristen fest und löschen Sie automatisch abgelaufene Daten.

DEVELOPERpython
from datetime import datetime, timedelta
from typing import Dict, List
import asyncio

class RetentionManager:
    """Verwaltet Aufbewahrung und Löschung von Daten."""

    # Durées de conservation par type de donnée (en jours)
    RETENTION_POLICIES = {
        "conversation_messages": 365,      # 1 an
        "user_preferences": 730,           # 2 ans
        "consent_records": 1825,           # 5 ans (obligation légale)
        "analytics_raw": 90,               # 3 mois
        "analytics_aggregated": 1095,      # 3 ans
        "support_tickets": 1095,           # 3 ans
        "embeddings_cache": 30,            # 1 mois
        "session_data": 1,                 # 1 jour
    }

    def __init__(self, db_connection, logger=None):
        self.db = db_connection
        self.logger = logger or logging.getLogger(__name__)

    async def get_retention_period(self, data_type: str) -> int:
        """Gibt die Aufbewahrungsdauer in Tagen zurück."""
        return self.RETENTION_POLICIES.get(data_type, 365)

    async def is_expired(
        self,
        data_type: str,
        created_at: datetime
    ) -> bool:
        """Prüft, ob eine Dateninstanz die Aufbewahrungsfrist überschritten hat."""
        retention_days = await self.get_retention_period(data_type)
        expiry_date = created_at + timedelta(days=retention_days)
        return datetime.utcnow() > expiry_date

    async def cleanup_expired_data(self) -> Dict[str, int]:
        """Löscht alle abgelaufenen Daten."""
        results = {}

        for data_type, retention_days in self.RETENTION_POLICIES.items():
            cutoff_date = datetime.utcnow() - timedelta(days=retention_days)

            deleted_count = await self.db.delete_before(
                table=data_type,
                date_column="created_at",
                cutoff=cutoff_date
            )

            results[data_type] = deleted_count

            if deleted_count > 0:
                self.logger.info(
                    f"Supprimé {deleted_count} enregistrements de {data_type} "
                    f"(antérieurs à {cutoff_date.date()})"
                )

        return results

    async def schedule_deletion(
        self,
        user_id: str,
        data_type: str,
        delay_days: int = 30
    ) -> Dict[str, Any]:
        """Plant eine verzögerte Löschung (Recht auf Vergessenwerden)."""
        deletion_date = datetime.utcnow() + timedelta(days=delay_days)

        job = {
            "user_id": user_id,
            "data_type": data_type,
            "scheduled_for": deletion_date.isoformat(),
            "status": "scheduled"
        }

        await self.db.create_deletion_job(job)

        return {
            "message": f"Suppression programmée pour le {deletion_date.date()}",
            "job_id": job.get("id"),
            "can_cancel_until": deletion_date.isoformat()
        }

6. Integrität und Vertraulichkeit

Schützen Sie Daten vor unbefugtem Zugriff und Manipulation.

DEVELOPERpython
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import base64
import os

class ConversationEncryption:
    """Verschlüsselung gespeicherter Konversationen."""

    def __init__(self, master_key: str):
        # Dériver une clé à partir du master key
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=b'ailog_salt_v1',  # En prod: salt unique par installation
            iterations=100000,
        )
        key = base64.urlsafe_b64encode(kdf.derive(master_key.encode()))
        self.cipher = Fernet(key)

    def encrypt_message(self, message: str) -> str:
        """Verschlüsselt eine Nachricht vor dem Speichern."""
        return self.cipher.encrypt(message.encode()).decode()

    def decrypt_message(self, encrypted: str) -> str:
        """Entschlüsselt eine Nachricht zur Anzeige."""
        return self.cipher.decrypt(encrypted.encode()).decode()

    def encrypt_conversation(
        self,
        messages: List[Dict[str, Any]]
    ) -> List[Dict[str, Any]]:
        """Verschlüsselt eine gesamte Konversation."""
        encrypted_messages = []
        for msg in messages:
            encrypted_msg = msg.copy()
            if "content" in msg:
                encrypted_msg["content"] = self.encrypt_message(msg["content"])
                encrypted_msg["_encrypted"] = True
            encrypted_messages.append(encrypted_msg)
        return encrypted_messages


class AccessControl:
    """Zugriffssteuerung auf Konversationsdaten."""

    def __init__(self, db_connection):
        self.db = db_connection

    async def can_access_conversation(
        self,
        requester_id: str,
        conversation_id: str,
        access_type: str = "read"
    ) -> bool:
        """Prüft, ob ein Nutzer auf eine Konversation zugreifen darf."""
        conversation = await self.db.get_conversation(conversation_id)
        if not conversation:
            return False

        # Der Eigentümer hat alle Rechte
        if conversation.user_id == requester_id:
            return True

        # Überprüfe explizite Berechtigungen
        permissions = await self.db.get_permissions(
            resource_type="conversation",
            resource_id=conversation_id,
            user_id=requester_id
        )

        return access_type in permissions.get("allowed_actions", [])

    async def log_access(
        self,
        user_id: str,
        resource: str,
        action: str,
        success: bool
    ):
        """Protokolliert einen Zugriff für das Audit."""
        await self.db.insert_audit_log({
            "timestamp": datetime.utcnow().isoformat(),
            "user_id": user_id,
            "resource": resource,
            "action": action,
            "success": success,
            "ip_address": self._get_current_ip()
        })

7. Verantwortlichkeit (Accountability)

Dokumentieren Sie Ihre Verarbeitungstätigkeiten und seien Sie in der Lage, Ihre Konformität nachzuweisen.

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

class GDPRDocumentation:
    """Erstellt die erforderliche DSGVO-Dokumentation."""

    def generate_processing_record(self) -> Dict[str, Any]:
        """Erstellt das Verzeichnis der Verarbeitungstätigkeiten (Artikel 30)."""
        return {
            "controller": {
                "name": "Votre Entreprise SAS",
                "address": "123 rue Example, 75001 Paris",
                "contact": "[email protected]"
            },
            "processing_activities": [
                {
                    "name": "Chatbot IA - Support client",
                    "purpose": "Répondre aux questions des utilisateurs",
                    "legal_basis": "Consentement (Art. 6.1.a)",
                    "data_categories": [
                        "Messages de conversation",
                        "Identifiants de session",
                        "Préférences utilisateur"
                    ],
                    "data_subjects": "Visiteurs du site web",
                    "recipients": [
                        "Équipe support interne",
                        "Sous-traitant hébergement (OVH)"
                    ],
                    "retention": "12 mois",
                    "security_measures": [
                        "Chiffrement au repos (AES-256)",
                        "Chiffrement en transit (TLS 1.3)",
                        "Pseudonymisation des identifiants",
                        "Contrôle d'accès par rôles"
                    ],
                    "transfers": {
                        "outside_eu": False
                    }
                }
            ],
            "generated_at": datetime.utcnow().isoformat(),
            "version": "1.0"
        }

    def generate_dpia(self) -> Dict[str, Any]:
        """Erstellt eine vereinfachte Datenschutz-Folgenabschätzung (DPIA)."""
        return {
            "project": "Chatbot IA RAG",
            "assessment_date": datetime.utcnow().date().isoformat(),
            "necessity_assessment": {
                "purpose_legitimate": True,
                "data_minimization": True,
                "proportionality": True
            },
            "risks_identified": [
                {
                    "risk": "Divulgation de données sensibles dans les réponses",
                    "likelihood": "Medium",
                    "impact": "High",
                    "mitigation": "Filtrage des données sensibles en sortie",
                    "residual_risk": "Low"
                },
                {
                    "risk": "Conservation excessive des conversations",
                    "likelihood": "Low",
                    "impact": "Medium",
                    "mitigation": "Politique de rétention automatique",
                    "residual_risk": "Low"
                }
            ],
            "conclusion": "Le traitement peut être mis en œuvre avec les mesures identifiées"
        }

Implementierung der Rechte betroffener Personen

Auskunftsrecht (Artikel 15)

DEVELOPERpython
class SubjectRights:
    """Implementierung der Rechte betroffener Personen."""

    def __init__(self, db, encryption, export_service):
        self.db = db
        self.encryption = encryption
        self.export_service = export_service

    async def handle_access_request(
        self,
        user_id: str,
        verification_token: str
    ) -> Dict[str, Any]:
        """Bearbeitet eine Anfrage auf Auskunft über personenbezogene Daten."""
        # Überprüfe die Identität des Antragstellers
        if not await self._verify_identity(user_id, verification_token):
            return {"error": "Verification failed", "status": 401}

        # Sammle alle Daten des Nutzers
        user_data = {
            "conversations": await self._get_user_conversations(user_id),
            "preferences": await self.db.get_user_preferences(user_id),
            "consent_records": await self.db.get_consent_history(user_id),
            "access_logs": await self.db.get_user_access_logs(user_id)
        }

        # Erstelle einen herunterladbaren Export
        export_file = await self.export_service.create_export(
            user_data,
            format="json",
            encrypted=True
        )

        return {
            "status": "success",
            "data_summary": {
                "conversations_count": len(user_data["conversations"]),
                "date_range": self._get_date_range(user_data),
                "data_types": list(user_data.keys())
            },
            "download_link": export_file.url,
            "expires_at": export_file.expires_at
        }

    async def _get_user_conversations(
        self,
        user_id: str
    ) -> List[Dict[str, Any]]:
        """Ruft verschlüsselte Nutzerkonversationen ab und entschlüsselt sie."""
        encrypted_convs = await self.db.get_conversations(user_id)

        decrypted = []
        for conv in encrypted_convs:
            messages = []
            for msg in conv.get("messages", []):
                if msg.get("_encrypted"):
                    content = self.encryption.decrypt_message(msg["content"])
                else:
                    content = msg["content"]
                messages.append({
                    "role": msg["role"],
                    "content": content,
                    "timestamp": msg["timestamp"]
                })
            decrypted.append({
                "conversation_id": conv["id"],
                "created_at": conv["created_at"],
                "messages": messages
            })

        return decrypted

Recht auf Löschung (Artikel 17)

DEVELOPERpython
async def handle_erasure_request(
    self,
    user_id: str,
    verification_token: str,
    reason: str = None
) -> Dict[str, Any]:
    """Behandelt eine Löschanfrage (Recht auf Vergessenwerden)."""
    if not await self._verify_identity(user_id, verification_token):
        return {"error": "Verification failed", "status": 401}

    # Liste der zu löschenden Daten
    deletion_targets = [
        ("conversations", self.db.delete_user_conversations),
        ("embeddings", self.db.delete_user_embeddings),
        ("preferences", self.db.delete_user_preferences),
        ("session_data", self.db.delete_user_sessions),
    ]

    # Zu behaltende Daten (gesetzliche Verpflichtungen)
    retained_data = [
        "consent_records",  # Conservation 5 ans
        "audit_logs"        # Conservation légale
    ]

    deletion_results = {}
    for target_name, delete_func in deletion_targets:
        try:
            count = await delete_func(user_id)
            deletion_results[target_name] = {
                "status": "deleted",
                "count": count
            }
        except Exception as e:
            deletion_results[target_name] = {
                "status": "error",
                "error": str(e)
            }

    # Protokolliere die Löschanfrage
    await self.db.log_erasure_request({
        "user_id": user_id,
        "requested_at": datetime.utcnow().isoformat(),
        "reason": reason,
        "results": deletion_results,
        "retained": retained_data
    })

    return {
        "status": "completed",
        "deleted": deletion_results,
        "retained": {
            "data_types": retained_data,
            "reason": "Conservation légale obligatoire"
        },
        "confirmation_sent_to": await self._get_user_email(user_id)
    }

Recht auf Datenübertragbarkeit (Artikel 20)

DEVELOPERpython
async def handle_portability_request(
    self,
    user_id: str,
    verification_token: str,
    format: str = "json"
) -> Dict[str, Any]:
    """Exportiert Daten in ein portables Format."""
    if not await self._verify_identity(user_id, verification_token):
        return {"error": "Verification failed", "status": 401}

    # Portierbare Daten (vom Nutzer bereitgestellt)
    portable_data = {
        "conversations": await self._get_user_conversations(user_id),
        "preferences": await self.db.get_user_preferences(user_id),
        "documents_uploaded": await self.db.get_user_documents(user_id)
    }

    # Export-Metadaten
    export_metadata = {
        "exported_at": datetime.utcnow().isoformat(),
        "format": format,
        "schema_version": "1.0",
        "source": "Ailog Chatbot",
        "user_id_hash": self._hash_user_id(user_id)
    }

    if format == "json":
        export_content = json.dumps({
            "metadata": export_metadata,
            "data": portable_data
        }, indent=2, ensure_ascii=False)
    elif format == "csv":
        export_content = self._convert_to_csv(portable_data)
    else:
        return {"error": f"Format non supporté: {format}"}

    # Erstelle die Export-Datei
    export_file = await self.export_service.create_download(
        content=export_content,
        filename=f"export_{user_id[:8]}_{format}",
        expires_hours=72
    )

    return {
        "status": "ready",
        "download_url": export_file.url,
        "format": format,
        "size_bytes": len(export_content),
        "expires_at": export_file.expires_at,
        "checksum": self._compute_checksum(export_content)
    }

Benutzeroberfläche für Compliance

Zustimmungsbanner für den Chatbot

DEVELOPERtypescript
// components/ChatConsentBanner.tsx
import { useState } from 'react';

interface ConsentBannerProps {
  onAccept: () => void;
  onDecline: () => void;
  onMoreInfo: () => void;
}

export function ChatConsentBanner({
  onAccept,
  onDecline,
  onMoreInfo
}: ConsentBannerProps) {
  const [expanded, setExpanded] = useState(false);

  return (
    <div className="bg-gray-50 border border-gray-200 rounded-lg p-4 mb-4">
      <p className="text-sm text-gray-700 mb-3">
        Ce chatbot utilise l'IA pour répondre à vos questions.
        Vos messages sont traités pour générer des réponses pertinentes.
      </p>

      {expanded && (
        <div className="text-xs text-gray-600 mb-3 space-y-2">
          <p>
            <strong>Données collectées :</strong> Messages, horodatage,
            identifiant de session anonyme.
          </p>
          <p>
            <strong>Durée de conservation :</strong> 12 mois maximum.
          </p>
          <p>
            <strong>Vos droits :</strong> Accès, rectification, effacement.
            Tapez /mes-donnees dans le chat pour les exercer.
          </p>
        </div>
      )}

      <div className="flex items-center gap-2">
        <button
          onClick={onAccept}
          className="px-4 py-2 bg-blue-600 text-white text-sm rounded hover:bg-blue-700"
        >
          Accepter
        </button>
        <button
          onClick={onDecline}
          className="px-4 py-2 border border-gray-300 text-sm rounded hover:bg-gray-100"
        >
          Refuser
        </button>
        <button
          onClick={() => setExpanded(!expanded)}
          className="px-4 py-2 text-sm text-gray-600 hover:text-gray-900"
        >
          {expanded ? 'Moins de détails' : 'Plus de détails'}
        </button>
      </div>
    </div>
  );
}

Im Chat integrierte Befehle

DEVELOPERpython
class GDPRChatCommands:
    """DSGVO-Befehle, direkt im Chat zugänglich."""

    COMMANDS = {
        "/mes-donnees": "access_request",
        "/supprimer-mes-donnees": "erasure_request",
        "/exporter-mes-donnees": "portability_request",
        "/retirer-consentement": "withdraw_consent",
        "/politique-confidentialite": "privacy_policy",
        "/aide-rgpd": "gdpr_help"
    }

    async def handle_command(
        self,
        command: str,
        user_id: str
    ) -> Dict[str, Any]:
        """Verarbeitet einen DSGVO-Befehl."""
        action = self.COMMANDS.get(command.lower())

        if not action:
            return None  # Kein DSGVO-Befehl

        if action == "access_request":
            return {
                "type": "gdpr_response",
                "message": """
                📋 **Demande d'accès à vos données**

                Pour recevoir une copie de vos données, nous devons vérifier
                votre identité. Un email de vérification va vous être envoyé.

                Une fois vérifié, vous recevrez un lien de téléchargement
                valide 72h contenant :
                - Vos conversations
                - Vos préférences
                - Votre historique de consentement
                """,
                "action_required": "email_verification"
            }

        elif action == "erasure_request":
            return {
                "type": "gdpr_response",
                "message": """
                🗑️ **Demande de suppression de vos données**

                Vous pouvez demander la suppression de vos données personnelles.

                Seront supprimés :
                - Toutes vos conversations
                - Vos préférences
                - Vos données de session

                Seront conservés (obligation légale) :
                - Registre de consentement (5 ans)
                - Logs de sécurité (1 an)

                ⚠️ Cette action est irréversible.
                Confirmez-vous la suppression ?
                """,
                "confirmation_required": True,
                "action": "confirm_erasure"
            }

        elif action == "gdpr_help":
            return {
                "type": "gdpr_response",
                "message": """
                🔒 **Vos droits sur vos données**

                Commandes disponibles :

                `/mes-donnees` - Voir quelles données nous avons sur vous
                `/exporter-mes-donnees` - Télécharger vos données
                `/supprimer-mes-donnees` - Demander l'effacement
                `/retirer-consentement` - Retirer votre consentement
                `/politique-confidentialite` - Lire notre politique

                Questions ? Contactez notre DPO : [email protected]
                """
            }

        # ... autres actions

Checkliste DSGVO-Compliance

Avant de déployer votre chatbot, vérifiez ces points :

Bases légales et consentement

• Consentement explicite demandé avant la première interaction
• Possibilité de refuser sans perte de fonctionnalité critique
• Mécanisme de retrait du consentement facilement accessible
• Registre des consentements horodaté et conservé

Transparenz

• Information claire sur les données collectées
• Mention de l'utilisation de l'IA
• Lien vers la politique de confidentialité
• Contact du DPO visible

Droits des personnes

• Procédure d'accès aux données (< 30 jours)
• Procédure de rectification
• Procédure d'effacement (droit à l'oubli)
• Export des données en format portable

Sicherheit

• Chiffrement des données au repos
• Chiffrement en transit (TLS)
• Contrôle d'accès par rôles
• Journalisation des accès

Conservation

• Durées de conservation définies par type de donnée
• Suppression automatique des données expirées
• Procédure de purge testée

Documentation

• Registre des traitements à jour
• DPIA réalisée si nécessaire
• Procédures de violation de données documentées
• Contrats de sous-traitance (DPA) signés

Fazit

Die DSGVO-Konformität eines KI-Chatbots ist keine Option, sondern eine gesetzliche Verpflichtung. Durch die Implementierung der in diesem Leitfaden beschriebenen Maßnahmen schützen Sie nicht nur Ihre Nutzer, sondern auch Ihr Unternehmen vor rechtlichen und reputativen Risiken.

Wesentliche Punkte :

1. Die Einwilligung ist die Basis - Keine Verarbeitung ohne ausdrückliche Einwilligung
2. Daten minimieren - Sammeln Sie nur das absolut Notwendige
3. Alles sichern - Verschlüsselung, Zugriffssteuerung, Protokollierung
4. Dokumentieren - Verzeichnis der Verarbeitung, DPIA, Verfahren
5. Ermöglichen Sie die Ausübung der Rechte - Klare Oberflächen, eingehaltene Fristen

Weiterführende Links

• AI Act européen : Impact sur les systèmes RAG - Comprendre les nouvelles réglementations
• Données sensibles : Filtrer et protéger les informations - Techniques de filtrage avancées
• Cloud souverain pour le RAG - Hébergement conforme en France