AI Act européen : Impact sur les systèmes RAG

L'AI Act (Règlement sur l'Intelligence Artificielle) est la première réglementation mondiale complète sur l'IA. Entré en vigueur en août 2024, il impacte directement les systèmes RAG déployés en Europe. Ce guide vous aide à comprendre vos obligations et à vous mettre en conformité.

Prérequis : Familiarisez-vous avec les fondamentaux du RAG et notre guide sur la sécurité et conformité RAG avant de continuer.

Qu'est-ce que l'AI Act ?

Contexte et objectifs

L'AI Act est un règlement européen qui établit un cadre juridique harmonisé pour l'intelligence artificielle. Ses objectifs principaux sont :

• Protéger les droits fondamentaux des citoyens européens
• Établir des règles claires pour les développeurs et déployeurs d'IA
• Favoriser l'innovation tout en limitant les risques
• Créer un marché unique pour les systèmes d'IA en Europe

Calendrier d'application

Qui est concerné ?

L'AI Act s'applique à :

• Fournisseurs : Ceux qui développent des systèmes d'IA
• Déployeurs : Ceux qui utilisent des systèmes d'IA dans un contexte professionnel
• Importateurs/Distributeurs : Ceux qui mettent sur le marché européen
• Fabricants de produits : Quand l'IA est intégrée dans un produit

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

class AIActRole(Enum):
    """Rôles définis par l'AI Act."""
    PROVIDER = "fournisseur"
    DEPLOYER = "déployeur"
    IMPORTER = "importateur"
    DISTRIBUTOR = "distributeur"
    PRODUCT_MANUFACTURER = "fabricant_produit"

@dataclass
class Organization:
    """Représentation d'une organisation sous l'AI Act."""
    name: str
    roles: List[AIActRole]
    location: str
    eu_representative: Optional[str] = None

    def needs_eu_representative(self) -> bool:
        """Vérifie si un représentant UE est nécessaire."""
        # Organisations hors UE vendant en UE
        return self.location not in EU_COUNTRIES and self._serves_eu_market()

    def primary_obligations(self) -> List[str]:
        """Retourne les obligations principales selon le rôle."""
        obligations = []

        if AIActRole.PROVIDER in self.roles:
            obligations.extend([
                "Système de gestion de la qualité",
                "Évaluation de conformité",
                "Documentation technique",
                "Marquage CE",
                "Déclaration de conformité UE"
            ])

        if AIActRole.DEPLOYER in self.roles:
            obligations.extend([
                "Utilisation conformément aux instructions",
                "Contrôle humain approprié",
                "Surveillance du système",
                "Conservation des logs",
                "Information des personnes concernées"
            ])

        return obligations

Classification des risques

L'AI Act classe les systèmes d'IA en quatre catégories de risque :

1. Risque inacceptable (Interdit)

Ces systèmes sont totalement interdits en Europe :

• Manipulation subliminale portant atteinte
• Exploitation des vulnérabilités (âge, handicap)
• Notation sociale par les autorités publiques
• Reconnaissance faciale en temps réel dans l'espace public (sauf exceptions)
• Catégorisation biométrique par données sensibles
• Reconnaissance des émotions au travail/école

DEVELOPERpython
class ProhibitedSystemChecker:
    """Vérifie si un système RAG utilise des pratiques interdites."""

    PROHIBITED_PRACTICES = {
        "subliminal_manipulation": {
            "description": "Techniques subliminales pour altérer le comportement",
            "indicators": [
                "messages_cachés",
                "influence_inconsciente",
                "dark_patterns_agressifs"
            ]
        },
        "vulnerability_exploitation": {
            "description": "Exploitation des vulnérabilités",
            "indicators": [
                "ciblage_age",
                "ciblage_handicap",
                "ciblage_situation_économique"
            ]
        },
        "social_scoring": {
            "description": "Notation sociale généralisée",
            "indicators": [
                "score_comportemental",
                "évaluation_trustworthiness",
                "classification_citoyens"
            ]
        },
        "emotion_recognition_workplace": {
            "description": "Reconnaissance des émotions au travail",
            "indicators": [
                "analyse_faciale_employés",
                "détection_stress_travail",
                "surveillance_émotionnelle"
            ]
        }
    }

    def check_system(self, system_config: dict) -> dict:
        """Analyse un système pour détecter des pratiques interdites."""
        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": "INTERDIT - Ne pas déployer" if violations else "OK"
        }

    def _detect_indicator(self, config: dict, indicator: str) -> bool:
        """Détecte un indicateur de pratique interdite."""
        # Implémentation de la détection
        # ...
        pass

2. Haut risque

Ces systèmes nécessitent une conformité stricte avant mise sur le marché :

Domaines concernés :

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

class RiskLevel(Enum):
    PROHIBITED = "interdit"
    HIGH = "haut"
    LIMITED = "limité"
    MINIMAL = "minimal"

class RAGRiskClassifier:
    """Classifie le niveau de risque d'un système RAG selon l'AI Act."""

    HIGH_RISK_DOMAINS = {
        "biometric_identification": {
            "keywords": ["reconnaissance faciale", "biométrie", "identification"],
            "threshold": 0.8
        },
        "critical_infrastructure": {
            "keywords": ["énergie", "transport", "eau", "infrastructure"],
            "threshold": 0.7
        },
        "education": {
            "keywords": ["admission", "notation", "examen", "évaluation scolaire"],
            "threshold": 0.7
        },
        "employment": {
            "keywords": ["recrutement", "CV", "candidature", "embauche", "RH"],
            "threshold": 0.8
        },
        "essential_services": {
            "keywords": ["crédit", "prêt", "assurance", "allocation", "aide sociale"],
            "threshold": 0.8
        },
        "law_enforcement": {
            "keywords": ["police", "criminalité", "risque", "profilage"],
            "threshold": 0.9
        },
        "migration": {
            "keywords": ["visa", "asile", "frontière", "immigration"],
            "threshold": 0.9
        },
        "justice": {
            "keywords": ["tribunal", "jugement", "peine", "récidive"],
            "threshold": 0.9
        }
    }

    def classify_rag_system(
        self,
        system_description: str,
        use_cases: List[str],
        data_types: List[str],
        decision_impact: str
    ) -> Dict:
        """Classifie un système RAG selon l'AI Act."""

        # Vérifier les pratiques interdites d'abord
        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": "Pratiques interdites détectées"
            }

        # Vérifier si haut risque
        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"Domaine(s) à haut risque: {', '.join(high_risk_matches)}"
            }

        # Vérifier si risque limité (transparence requise)
        if self._is_limited_risk(use_cases, data_types):
            return {
                "risk_level": RiskLevel.LIMITED,
                "can_deploy": True,
                "requirements": ["Obligation de transparence"],
                "reason": "Interaction directe avec les utilisateurs"
            }

        # Par défaut: risque minimal
        return {
            "risk_level": RiskLevel.MINIMAL,
            "can_deploy": True,
            "requirements": [],
            "reason": "Pas de domaine sensible identifié"
        }

    def _check_high_risk_domains(
        self,
        description: str,
        use_cases: List[str]
    ) -> List[str]:
        """Identifie les domaines à haut risque."""
        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]:
        """Retourne les exigences pour les systèmes à haut risque."""
        return [
            "Système de gestion des risques",
            "Gouvernance des données",
            "Documentation technique",
            "Tenue de registres (logs)",
            "Transparence et information",
            "Contrôle humain",
            "Exactitude, robustesse, cybersécurité",
            "Évaluation de conformité",
            "Déclaration CE de conformité",
            "Enregistrement dans la base de données UE"
        ]

3. Risque limité

Ces systèmes ont uniquement des obligations de transparence :

• Chatbots et assistants IA (y compris RAG)
• Systèmes de génération de contenu
• Deep fakes et contenu synthétique
• Systèmes de catégorisation par émotions

DEVELOPERpython
class TransparencyRequirements:
    """Exigences de transparence pour systèmes à risque limité."""

    def generate_disclosure(self, system_type: str) -> str:
        """Génère le texte de divulgation requis."""

        disclosures = {
            "chatbot": """
                Vous interagissez avec un système d'intelligence artificielle.
                Ce chatbot utilise la technologie RAG (Retrieval-Augmented Generation)
                pour générer ses réponses à partir d'une base de connaissances.

                Les réponses sont générées automatiquement et peuvent contenir
                des inexactitudes. Pour les décisions importantes, veuillez
                consulter un expert humain.
            """,

            "content_generation": """
                Ce contenu a été généré ou assisté par intelligence artificielle.
                Il peut contenir des erreurs ou des informations obsolètes.
                Vérifiez les informations importantes auprès de sources primaires.
            """,

            "emotion_detection": """
                Ce système utilise l'intelligence artificielle pour analyser
                certains aspects de votre communication. Vous avez le droit
                de refuser cette analyse.
            """
        }

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

    def get_required_disclosures(self, system_config: dict) -> List[dict]:
        """Retourne toutes les divulgations requises."""
        disclosures = []

        # Divulgation que c'est une IA
        if system_config.get("user_interaction"):
            disclosures.append({
                "type": "ai_interaction",
                "when": "Avant première interaction",
                "content": self.generate_disclosure("chatbot"),
                "format": ["texte_visible", "audio_si_vocal"]
            })

        # Divulgation de contenu généré
        if system_config.get("generates_content"):
            disclosures.append({
                "type": "generated_content",
                "when": "Avec chaque contenu généré",
                "content": self.generate_disclosure("content_generation"),
                "format": ["watermark", "métadonnées", "mention_visible"]
            })

        return disclosures

4. Risque minimal

Pas d'obligations spécifiques, mais bonnes pratiques recommandées :

• Filtres anti-spam
• Jeux vidéo avec IA
• Systèmes de recommandation basiques

Où se situent les systèmes RAG ?

Cas général : Risque limité

La plupart des chatbots RAG tombent dans la catégorie risque limité :

DEVELOPERpython
def classify_typical_rag_chatbot() -> dict:
    """Classification d'un chatbot RAG standard."""

    classifier = RAGRiskClassifier()

    # Chatbot support client e-commerce
    result = classifier.classify_rag_system(
        system_description="Chatbot de support client pour site e-commerce",
        use_cases=[
            "Répondre aux questions sur les produits",
            "Aider avec le suivi de commande",
            "Expliquer les politiques de retour"
        ],
        data_types=["catalogue_produits", "FAQ", "conditions_générales"],
        decision_impact="faible"  # Pas de décision significative
    )

    return result
    # Résultat attendu:
    # {
    #     "risk_level": RiskLevel.LIMITED,
    #     "can_deploy": True,
    #     "requirements": ["Obligation de transparence"],
    #     "reason": "Interaction directe avec les utilisateurs"
    # }

Cas haut risque : RAG en RH ou finance

Certains déploiements RAG peuvent être haut risque :

DEVELOPERpython
def classify_hr_rag_system() -> dict:
    """Classification d'un système RAG pour le recrutement."""

    classifier = RAGRiskClassifier()

    # Système d'aide au recrutement
    result = classifier.classify_rag_system(
        system_description="Système RAG d'analyse et présélection de CVs",
        use_cases=[
            "Analyser les CVs des candidats",
            "Classer les candidatures",
            "Suggérer les meilleurs profils",
            "Générer des questions d'entretien"
        ],
        data_types=["CVs", "fiches_poste", "historique_recrutement"],
        decision_impact="élevé"  # Affecte l'embauche
    )

    return result
    # Résultat attendu:
    # {
    #     "risk_level": RiskLevel.HIGH,
    #     "matched_domains": ["employment"],
    #     "can_deploy": True,
    #     "requirements": [...10 exigences...],
    #     "reason": "Domaine(s) à haut risque: employment"
    # }

Obligations pour les systèmes RAG à haut risque

Si votre système RAG est classé haut risque, voici vos obligations :

1. Système de gestion des risques

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

class RiskManagementSystem:
    """Système de gestion des risques conforme AI Act."""

    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]]:
        """Identifie les risques du système RAG."""
        risks = [
            {
                "id": "R001",
                "category": "accuracy",
                "description": "Réponses incorrectes ou hallucinations",
                "likelihood": "medium",
                "impact": "high",
                "affected_rights": ["droit à l'information exacte"]
            },
            {
                "id": "R002",
                "category": "bias",
                "description": "Biais dans les données d'entraînement",
                "likelihood": "medium",
                "impact": "high",
                "affected_rights": ["non-discrimination"]
            },
            {
                "id": "R003",
                "category": "privacy",
                "description": "Divulgation de données personnelles",
                "likelihood": "low",
                "impact": "very_high",
                "affected_rights": ["vie privée", "protection données"]
            },
            {
                "id": "R004",
                "category": "security",
                "description": "Injection de prompt malveillant",
                "likelihood": "medium",
                "impact": "medium",
                "affected_rights": ["sécurité"]
            },
            {
                "id": "R005",
                "category": "transparency",
                "description": "Manque d'explicabilité des réponses",
                "likelihood": "high",
                "impact": "medium",
                "affected_rights": ["droit à l'explication"]
            }
        ]

        self.risk_registry = risks
        return risks

    def define_mitigations(self) -> List[Dict[str, Any]]:
        """Définit les mesures d'atténuation."""
        mitigations = [
            {
                "risk_id": "R001",
                "measure": "Fact-checking automatique",
                "implementation": "Vérification des réponses contre sources fiables",
                "status": "implemented",
                "effectiveness": "high"
            },
            {
                "risk_id": "R001",
                "measure": "Disclaimer systématique",
                "implementation": "Avertissement sur les limites de l'IA",
                "status": "implemented",
                "effectiveness": "medium"
            },
            {
                "risk_id": "R002",
                "measure": "Audit des données",
                "implementation": "Revue trimestrielle des biais potentiels",
                "status": "scheduled",
                "effectiveness": "medium"
            },
            {
                "risk_id": "R003",
                "measure": "Filtrage PII",
                "implementation": "Détection et masquage des données personnelles",
                "status": "implemented",
                "effectiveness": "high"
            },
            {
                "risk_id": "R004",
                "measure": "Validation des inputs",
                "implementation": "Détection des tentatives d'injection",
                "status": "implemented",
                "effectiveness": "high"
            },
            {
                "risk_id": "R005",
                "measure": "Citations des sources",
                "implementation": "Affichage des documents utilisés",
                "status": "implemented",
                "effectiveness": "high"
            }
        ]

        self.mitigation_measures = mitigations
        return mitigations

    def generate_report(self) -> Dict[str, Any]:
        """Génère un rapport de gestion des risques."""
        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:
        """Calcule le taux de couverture des risques."""
        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. Gouvernance des données

DEVELOPERpython
class DataGovernanceSystem:
    """Système de gouvernance des données pour RAG AI Act."""

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

    def register_data_source(self, source: Dict[str, Any]) -> None:
        """Enregistre une source de données avec métadonnées requises."""
        source_record = {
            "id": source["id"],
            "name": source["name"],
            "type": source["type"],  # documents, API, base de données

            # Informations de qualité (Article 10)
            "quality_assessment": {
                "completeness": source.get("completeness_score"),
                "accuracy": source.get("accuracy_score"),
                "timeliness": source.get("last_updated"),
                "representativeness": source.get("representativeness_score")
            },

            # Traçabilité
            "origin": source.get("origin"),
            "collection_method": source.get("collection_method"),
            "preprocessing": source.get("preprocessing_steps", []),

            # Biais et limites
            "known_biases": source.get("known_biases", []),
            "limitations": source.get("limitations", []),
            "gaps": source.get("data_gaps", []),

            # Conformité
            "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]:
        """Évalue la qualité des données conformément à l'Article 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

        # Recommandations
        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]:
        """Vérifie la représentativité des données."""
        # Analyse de la distribution des données
        issues = []
        score = 0.8  # Score par défaut

        # Vérifier la diversité géographique
        # Vérifier la diversité temporelle
        # Vérifier la couverture des cas d'usage

        return {
            "score": score,
            "issues": issues,
            "recommended_action": "Diversifier les sources de données"
        }

3. Documentation technique

DEVELOPERpython
class TechnicalDocumentation:
    """Génère la documentation technique requise par l'AI Act."""

    def generate_full_documentation(
        self,
        system_config: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Génère la documentation complète Article 11."""

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

            # 1. Description générale
            "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. Éléments du système
            "system_elements": {
                "architecture": self._describe_architecture(system_config),
                "components": [
                    {
                        "name": "Retrieval Engine",
                        "type": "vector_search",
                        "description": "Recherche sémantique dans la base documentaire"
                    },
                    {
                        "name": "LLM Generator",
                        "type": "language_model",
                        "description": "Génération de réponses contextualisées"
                    },
                    {
                        "name": "Document Store",
                        "type": "database",
                        "description": "Stockage des documents et embeddings"
                    }
                ],
                "external_dependencies": system_config.get("dependencies", [])
            },

            # 3. Processus de développement
            "development_process": {
                "methodology": "agile_mlops",
                "quality_assurance": self._describe_qa_process(),
                "testing_procedures": self._describe_testing(),
                "validation_metrics": self._list_metrics()
            },

            # 4. Capacités et limitations
            "capabilities_limitations": {
                "intended_capabilities": [
                    "Répondre aux questions sur la documentation",
                    "Fournir des informations factuelles",
                    "Citer les sources utilisées"
                ],
                "known_limitations": [
                    "Ne peut pas accéder à internet en temps réel",
                    "Peut produire des hallucinations",
                    "Limité aux connaissances de la base documentaire",
                    "Ne comprend pas les images ou fichiers audio"
                ],
                "foreseeable_misuse": [
                    "Utilisation pour décisions médicales sans supervision",
                    "Utilisation pour conseils juridiques définitifs",
                    "Génération de contenu trompeur"
                ]
            },

            # 5. Contrôle humain
            "human_oversight": {
                "oversight_measures": self._describe_oversight(),
                "intervention_capabilities": [
                    "Arrêt d'urgence du système",
                    "Correction manuelle des réponses",
                    "Révision des sources documentaires"
                ],
                "recommended_competencies": [
                    "Connaissance du domaine métier",
                    "Compréhension des limites de l'IA",
                    "Formation à l'outil spécifique"
                ]
            },

            # 6. Métriques de performance
            "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. Cybersécurité
            "cybersecurity": {
                "security_measures": [
                    "Chiffrement des données au repos (AES-256)",
                    "TLS 1.3 pour les communications",
                    "Authentification multi-facteur",
                    "Logs d'audit immuables"
                ],
                "vulnerability_assessment": {
                    "last_pentest": "2026-01-15",
                    "critical_vulnerabilities": 0,
                    "remediation_status": "completed"
                }
            }
        }

    def _describe_architecture(self, config: Dict) -> Dict:
        """Décrit l'architecture du système."""
        return {
            "type": "RAG (Retrieval-Augmented Generation)",
            "diagram_reference": "architecture_diagram_v1.png",
            "data_flow": [
                "1. Réception de la question utilisateur",
                "2. Embedding de la question",
                "3. Recherche des documents pertinents",
                "4. Construction du contexte",
                "5. Génération de la réponse par LLM",
                "6. Post-traitement et citations",
                "7. Retour de la réponse à l'utilisateur"
            ]
        }

4. Tenue des registres (logs)

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

class AIActLogger:
    """Système de logs conforme aux exigences 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]:
        """Enregistre une interaction conforme AI Act."""

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

            # Données d'entrée (hashées pour confidentialité)
            "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)
            },

            # Processus de décision
            "retrieval": {
                "documents_retrieved": len(retrieved_docs),
                "document_ids": retrieved_docs,
                "retrieval_scores": metadata.get("scores", []),
                "retrieval_time_ms": metadata.get("retrieval_time")
            },

            # Sortie
            "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", [])
            },

            # Métadonnées techniques
            "technical": {
                "model_version": metadata.get("model_version"),
                "embedding_model": metadata.get("embedding_model"),
                "temperature": metadata.get("temperature"),
                "max_tokens": metadata.get("max_tokens")
            },

            # Informations de contrôle
            "oversight": {
                "human_review_required": metadata.get("needs_review", False),
                "flagged_issues": metadata.get("flags", []),
                "automated_checks_passed": metadata.get("checks_passed", True)
            }
        }

        # Stocker le log
        await self.storage.store(log_entry)

        # Log structuré pour 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]:
        """Enregistre un incident pour traçabilité."""

        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:
        """Génère un ID unique pour le log."""
        timestamp = datetime.utcnow().isoformat()
        return hashlib.sha256(
            f"{self.system_id}:{timestamp}:{id(self)}".encode()
        ).hexdigest()[:16]

    def _hash_content(self, content: str) -> str:
        """Hash le contenu pour stockage anonymisé."""
        return hashlib.sha256(content.encode()).hexdigest()

Obligations de transparence pour les chatbots RAG

Même en risque limité, les systèmes RAG ont des obligations de transparence :

Implémentation de la divulgation

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">
            Vous interagissez avec {systemName}, un assistant IA
          </p>

          <details className="mt-2">
            <summary className="cursor-pointer text-blue-700 hover:text-blue-800">
              En savoir plus sur ce système
            </summary>

            <div className="mt-3 space-y-3 text-blue-800">
              <div>
                <h4 className="font-medium">Capacités</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">Limitations</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">Utilisation des données</h4>
                <p>{dataUsage}</p>
              </div>
            </div>
          </details>
        </div>
      </div>
    </div>
  );
}

// Utilisation
<AIDisclosure
  systemName="Assistant Ailog"
  capabilities={[
    "Répondre aux questions sur vos produits",
    "Fournir des informations de la documentation",
    "Citer les sources utilisées"
  ]}
  limitations={[
    "Peut produire des réponses inexactes",
    "Ne peut pas accéder à des informations en temps réel",
    "Ne remplace pas un conseiller humain"
  ]}
  dataUsage="Vos messages sont utilisés uniquement pour générer des réponses. Ils sont conservés 30 jours puis supprimés."
/>

Checklist de conformité AI Act

Pour tous les systèmes RAG (risque limité)

• Divulgation claire que l'utilisateur interagit avec une IA
• Information sur les capacités et limitations
• Mécanisme de contact humain si nécessaire
• Marquage du contenu généré par IA

Pour les systèmes RAG à haut risque (supplémentaire)

• Système de gestion des risques documenté
• Gouvernance des données avec traçabilité
• Documentation technique complète
• Logs d'utilisation conformes
• Mesures de contrôle humain implémentées
• Tests de robustesse et cybersécurité
• Évaluation de conformité réalisée
• Déclaration CE de conformité
• Enregistrement dans la base de données UE
• Procédure de surveillance post-déploiement

Conclusion

L'AI Act représente un changement majeur pour les systèmes RAG déployés en Europe. La bonne nouvelle : la plupart des chatbots RAG sont classés en risque limité et n'ont que des obligations de transparence. Cependant, si vous opérez dans des domaines sensibles (RH, finance, santé), vous devrez vous conformer aux exigences des systèmes à haut risque.

Points clés à retenir :

1. Classifiez votre système - Déterminez votre niveau de risque
2. La transparence est obligatoire - Informez toujours que c'est une IA
3. Documentez tout - Gardez des traces de vos décisions et processus
4. Préparez-vous tôt - L'application complète arrive en août 2026

Pour aller plus loin

• RGPD et chatbots IA - Conformité données personnelles
• Audit trail RAG - Traçabilité des requêtes
• Évaluation des systèmes RAG - Métriques de qualité