IA et données

Utiliser les LLM avec vos données : approches pratiques

Des modèles d’ingénierie pour relier des applications LLM aux données d’entreprise avec une récupération contrôlée, des outils et une autorisation fiable.

Par JaviPublié 11 min de lecture

Illustration abstraite d’un cerveau lumineux portant la mention AI

Un LLM peut produire un texte fluide, mais cette fluidité ne prouve pas qu’il connaît les données actuelles de votre organisation, ses définitions ou ses règles d’accès. Une application utile doit récupérer ou calculer les faits pertinents, autoriser l’utilisateur à les consulter et limiter les actions que le modèle peut effectuer.

Le LLM n’est donc qu’un composant de l’architecture applicative. L’application a toujours besoin des fondamentaux de l’ingénierie : API, identité, autorisations, schémas, validation, supervision, tests et code déterministe. Les modèles ci-dessous se concentrent sur ces frontières plutôt que sur le discours promotionnel autour des modèles.

La distinction essentielle

L’entraînement donne au modèle des capacités générales et des connaissances publiques jusqu’à la période où il a été entraîné. Il ne lui donne pas automatiquement accès à une table privée des ventes, à l’exécution du pipeline d’hier, à une politique interne ou au sens métier d’un « client actif ». Même si des informations similaires ont pu figurer dans les données d’entraînement, elles ne doivent pas être considérées comme une copie faisant autorité des données d’entreprise.

À la réception d’une demande, l’application fournit un contexte contrôlé. Celui-ci peut provenir de documents récupérés, d’un résultat SQL, d’un service de métriques sémantiques ou d’une fonction applicative approuvée. Le mécanisme doit renvoyer la plus petite quantité d’informations pertinentes et autorisées nécessaire à la tâche.

Cette séparation est utile. La plateforme de données reste le système de référence. Les services déterministes effectuent les calculs et appliquent les autorisations. Le LLM interprète une question, choisit parmi les capacités permises et formule un résultat. Il ne doit pas devenir une base de données parallèle sans gouvernance.

Modèle 1 : Retrieval-Augmented Generation

Retrieval-Augmented Generation, ou RAG, récupère le contexte pertinent avant de demander une réponse au modèle :

  1. Question de l’utilisateur
  2. Récupération du contexte pertinent
  3. Construction d’un prompt et d’un contexte bornés
  4. LLM
  5. Réponse accompagnée de références
Retrieval-Augmented Generation

Pour les données non structurées, la récupération recherche souvent des fragments de documents à l’aide de mots-clés, d’embeddings, de filtres de métadonnées ou d’une combinaison de ces méthodes. Le découpage doit respecter les frontières utiles des documents : une section de politique complète fournit généralement un meilleur contexte que des fragments arbitraires qui omettent définitions ou exceptions. Stockez l’identifiant de la source et les métadonnées d’accès avec chaque fragment afin que l’application puisse autoriser son utilisation et le citer.

Les données structurées peuvent également participer à la récupération. Un catalogue peut renvoyer des descriptions de tables, des définitions de métriques, de la documentation de schéma ou des résumés précalculés. Récupérer un schéma ne revient toutefois pas à récupérer la réponse. Si la question porte sur le chiffre d’affaires actuel, une requête contrôlée ou une fonction de métrique doit le calculer à partir du système de référence.

La qualité d’un RAG ne dépend pas uniquement du modèle. Évaluez si la bonne source a été retrouvée, si le contexte contient la réponse, si celle-ci est étayée par ce contexte et si les citations renvoient à des éléments accessibles. Une réponse soignée fondée sur le mauvais document reste incorrecte.

Modèle 2 : LLM et SQL

Le text-to-SQL peut rendre l’exploration des données plus accessible, mais exécuter directement une sortie arbitraire du modèle est dangereux. La requête pourrait accéder à des données non autorisées, lancer des scans coûteux, exposer des colonnes sensibles ou modifier la base.

Un flux contrôlé sépare l’interprétation, la validation, l’exécution et l’explication :

  1. Question de l’utilisateur
  2. Classer l’intentionChoisir un domaine de données approuvé
  3. Générer une requête contrainteOu choisir un modèle de requête
  4. Valider la requête
    • tables
    • colonnes
    • opérations
    • périmètre
    • coûts
  5. Exécuter avec une identité en lecture seule
  6. Renvoyer un résultat borné
  7. Le LLM explique le résultat
Un flux LLM et SQL contrôlé

Préférez une liste d’autorisation de schémas, de vues et d’opérations. Utilisez un parseur ou une couche de validation consciente de la base plutôt que de rechercher des mots dangereux dans le texte SQL. Imposez des identifiants en lecture seule, des limites de lignes, des délais d’exécution et une gouvernance des ressources à la frontière de la base. L’autorisation doit être appliquée avant l’exécution : demander au modèle de se souvenir des règles de sécurité ne constitue pas un contrôle d’autorisation.

Pour les questions connues, des modèles de requête ou des procédures stockées sont plus sûrs et plus faciles à tester qu’une génération ouverte. Le modèle peut associer « afficher les ventes régionales du mois dernier » à une fonction de rapport approuvée et lui fournir des paramètres validés. Réservez la génération SQL flexible aux environnements où sa valeur justifie les contrôles supplémentaires.

Modèle 3 : couche sémantique

Les schémas de base de données décrivent le stockage, pas toujours le sens métier. Le modèle peut voir net_amt sans savoir si cette valeur inclut les taxes, les retours ou la conversion des devises. Une couche sémantique fournit à l’application une représentation préparée des métriques, champs, relations et définitions.

Un contexte sémantique utile comprend :

  • les métriques métier approuvées et la responsabilité de leur calcul ;
  • des descriptions de champs compréhensibles et leurs unités ;
  • les tables ou vues autorisées ;
  • les relations valides et le sens des jointures ;
  • les synonymes employés par les équipes métier ;
  • les règles de fraîcheur, de granularité et de date d’effet ;
  • les champs qui ne doivent pas être exposés au modèle.

Cette couche réduit l’ambiguïté et crée un contrat testable indépendamment du prompt. Elle permet également à la même définition de métrique d’alimenter des rapports, des API et des expériences avec LLM. Ne dupliquez pas une règle de calcul critique dans le texte d’un prompt lorsqu’un service de métriques gouverné peut la calculer de façon déterministe.

Modèle 4 : outils et appels de fonctions

Les outils permettent au modèle de demander des actions applicatives contrôlées au lieu de recevoir un accès système sans restriction. L’application publie une capacité limitée avec un contrat d’entrée et de sortie typé :

get_sales_summary(start_date, end_date, region)
get_customer_metrics(customer_id)
run_approved_report(report_name, parameters)

Le modèle peut proposer un appel d’outil, mais l’application valide ses arguments, vérifie les autorisations de l’utilisateur, exécute l’implémentation et renvoie un résultat borné. Un outil doit représenter une capacité métier, pas une console SQL ou un shell sans restriction déguisé.

Limitez suffisamment la portée des outils pour pouvoir les tester. Documentez les unités et la sémantique des dates. Renvoyez des erreurs structurées distinguant un paramètre invalide, une demande non autorisée, des données absentes et une défaillance de dépendance. Le modèle peut alors expliquer le résultat sans en inventer un.

Les appels d’outils améliorent aussi l’observabilité. L’application sait quelle capacité a été exécutée, avec quels paramètres approuvés et sur quelle source de données. C’est bien plus facile à auditer que d’essayer de déduire le comportement à partir d’un long prompt.

La sécurité relève de l’application

Authentifiez l’utilisateur avant tout accès aux données d’entreprise. Autorisez chaque récupération, requête ou appel d’outil en fonction de son identité. Appliquez les contrôles au niveau des lignes et des tenants dans les couches applicatives ou plateformes de données de confiance, et pas seulement dans des instructions en langage naturel.

Utilisez des identités distinctes avec le minimum de privilèges. Stockez les secrets dans un gestionnaire adapté ou une configuration d’environnement ; ne les placez jamais dans les prompts. Considérez les documents récupérés et les valeurs de la base comme des entrées non fiables : ils peuvent contenir des instructions conçues pour manipuler le modèle. L’injection de prompt ne vient pas uniquement de la question de l’utilisateur ; elle peut aussi être intégrée à un document récupéré par le système.

Définissez quels champs sensibles peuvent entrer dans le contexte du modèle et lesquels doivent être masqués, agrégés ou exclus. Prenez en compte le traitement des données par le fournisseur du modèle, la rétention, les exigences régionales et la journalisation. L’isolation des tenants doit être maintenue dans tous les parcours, y compris les caches, traces, messages d’erreur et jeux de données d’évaluation.

Enfin, validez les sorties avant qu’elles ne déclenchent une action externe. Une explication générée peut être présentée avec des citations ; une mise à jour à fort impact, une notification ou une opération financière exige des contrôles déterministes et souvent une validation humaine explicite.

Exemple avec des données structurées

L’exemple suivant garde l’accès aux données derrière une fonction approuvée. Le client du modèle est volontairement abstrait : les identifiants et la configuration du fournisseur doivent se trouver dans l’environnement ou une configuration gérée, pas dans le code source.

from dataclasses import dataclass, asdict
import json
import os

@dataclass
class SalesSummary:
    period: str
    region: str
    order_count: int
    net_sales: float

def get_sales_summary(user, period: str, region: str) -> SalesSummary:
    if not user.can_read_region(region):
        raise PermissionError("Region is not authorized")

    # In production, call a parameterized query or governed metric service.
    return reporting_service.sales_summary(period=period, region=region)

def answer_sales_question(user, question: str, period: str, region: str):
    summary = get_sales_summary(user, period, region)
    context = json.dumps(asdict(summary))

    prompt = f"""Explain this approved sales summary.
Use only the supplied JSON. State when the data is insufficient.

Question: {question}
Data: {context}
"""

    model_name = os.environ["LLM_MODEL_NAME"]
    return model_client.generate(model=model_name, prompt=prompt)

L’exemple n’est pas du code de production complet, mais ses frontières sont importantes : l’autorisation est vérifiée avant la récupération des données, la fonction renvoie une structure définie, le prompt limite les éléments de preuve et aucune clé API n’est intégrée au programme. Une implémentation de production ajouterait la validation des entrées, des délais d’attente, une stratégie de nouvelle tentative, des contrôles de sortie et une télémétrie structurée.

Les grands volumes restent dans la plateforme de données

N’envoyez pas des milliards de lignes — ni même une grande extraction brute — à un LLM. Les modèles ne sont pas des moteurs de requêtes, et les fenêtres de contexte ne remplacent pas une architecture de stockage et de calcul.

Filtrez selon le périmètre autorisé de l’utilisateur, calculez les métriques en SQL ou Spark, agrégez à la granularité requise et ne récupérez que les documents ou enregistrements pertinents. Fournissez ensuite au modèle un résultat compact qu’il pourra expliquer ou comparer. Si la tâche exige un calcul exact, effectuez-le dans le code et laissez le modèle le communiquer.

Cette répartition améliore la justesse, la latence, la sécurité et le coût. Elle clarifie également les tests : la fonction de données peut être testée sur ses valeurs exactes, tandis que la couche de langage peut être évaluée sur la fidélité de son explication.

Mettre en cache avec précaution

Le cache peut réduire le travail répété sur les données et les appels au modèle. Parmi les bons candidats : les rapports approuvés souvent demandés, les résultats de récupération de documents stables, les embeddings et les résumés générés dont les données source n’ont pas changé.

Chaque clé de cache doit inclure les dimensions qui influencent l’autorisation et le sens : tenant, périmètre ou rôle de l’utilisateur, paramètres, version de la source, version du modèle et, si nécessaire, version du prompt ou de l’outil. Un cache qui ignore l’identité du tenant peut provoquer une fuite de données.

Définissez explicitement la fraîcheur. Un résumé quotidien de gestion et un assistant d’incident en direct n’ont pas la même tolérance. Invalidez les explications mises en cache lorsque la version de la métrique ou du document sous-jacent change. Séparez les résultats déterministes de données des formulations générées lorsque cela améliore le contrôle.

Observabilité sans collecte imprudente de données

Une application LLM nécessite une télémétrie qui couvre à la fois les services habituels et les interactions avec le modèle. Un enregistrement de requête utile peut contenir :

  • un identifiant de requête ou de corrélation ;
  • le tenant authentifié et une référence utilisateur non sensible ;
  • la version du modèle et de sa configuration ;
  • la latence totale et celle des dépendances ;
  • les outils sélectionnés et leurs résultats ;
  • les identifiants des sources de données et documents ;
  • l’utilisation de tokens ;
  • la décision de validation ou de sécurité ;
  • une catégorie d’erreur expurgée.

Ne journalisez pas systématiquement les prompts complets, le contexte récupéré ou les réponses du modèle. Ils peuvent contenir des données personnelles, des secrets ou des informations métier. Préférez des métadonnées structurées, l’expurgation, un échantillonnage contrôlé et un stockage de diagnostic à accès restreint. La capture détaillée du contenu doit relever d’une décision explicite de politique, et non du paramétrage par défaut du SDK.

Suivez la requête à travers la récupération, SQL, les outils et les appels au modèle à l’aide d’un identifiant de corrélation unique. Un ingénieur pourra ainsi distinguer une récupération lente d’une génération lente et déterminer si une réponse incorrecte vient d’un contexte manquant, d’une requête erronée ou d’une sortie du modèle non étayée.

Maîtriser les coûts par l’architecture

Le coût dépend du volume de requêtes, de la taille du contexte et de la réponse, du choix du modèle, des nouvelles tentatives et du travail répété. Utilisez le modèle le moins complexe qui répond au besoin évalué. Récupérez moins de contexte, mais de meilleure qualité. Résumez une fois les documents stables lorsque c’est pertinent. Placez le routage déterministe et la validation hors du modèle.

Évitez d’envoyer le même catalogue de schémas ou le même ensemble de politiques à chaque demande lorsqu’un contrat d’outil plus restreint suffit. Limitez la taille des réponses. Détectez les boucles de nouvelles tentatives. Mesurez le coût par tâche utile plutôt que le coût par appel au modèle. Les tarifs des fournisseurs évoluent ; l’architecture doit exposer l’utilisation et la configuration au lieu d’intégrer des hypothèses sur une grille tarifaire actuelle.

Exemple d’architecture

  1. Utilisateur

    • Client UI ou API
  2. Application

    • Application / orchestrationGère la demande et la conversation
  3. Authentification

    • Authentification
    • Autorisation

    Frontière de confiance : appliquée avant toute sortie des données de leur couche gouvernée.

  4. Outils

    • Récupération
    • SQL contrôlé
    • Appels d’outils / fonctions
  5. Plateforme de données

    • Plateforme de données gouvernéeSécurité au niveau des lignes et des colonnes
  6. LLM

    • LLMNe reçoit qu’un contexte sélectionné et limité
  7. Réponse

    • Réponse validéeVérifiée avant affichage ou action

Enjeux transversaux

  • Journalisation d’audit
  • Évaluation
  • Limites de coût
  • Cache
Architecture contrôlée pour des LLM reliés aux données d’entreprise. L’identité est vérifiée avant la lecture des données, le modèle ne reçoit qu’un contexte sélectionné et la sortie est validée avant d’être présentée à l’utilisateur.

L’ordre exact peut varier — un outil peut appeler la plateforme de données puis le modèle, par exemple — mais les frontières de confiance doivent rester visibles. L’identité et l’autorisation s’appliquent avant que les données ne quittent leur couche gouvernée. Le modèle reçoit un contexte sélectionné. La sortie est validée avant la présentation d’une réponse ou la proposition d’une action.

Les travaux connexes couvrent la supervision des pipelines de données en production et la conception du projet AI Data Assistant.

Quand ne pas utiliser de LLM

Utilisez une requête SQL classique lorsque l’utilisateur a besoin d’une table ou d’une métrique exacte et que l’interprétation en langage naturel n’apporte rien. Utilisez des règles métier déterministes pour l’éligibilité, la tarification, la conformité et les autres décisions qui doivent être prévisibles et auditables. Utilisez la recherche classique lorsque des mots-clés ou des filtres suffisent déjà. Effectuez les calculs dans le code au lieu de demander au modèle de jouer le rôle d’une calculatrice.

Un LLM est utile lorsque le langage est central : interpréter des questions variées, synthétiser un petit nombre de sources autorisées, expliquer un résultat structuré ou aider à choisir parmi des capacités contrôlées. Il ajoute un risque inutile lorsque le besoin est déjà précis et déterministe.

Conclusion

Les applications utiles qui relient des LLM aux données ne contournent pas l’ingénierie des données ; elles en dépendent. Des définitions gouvernées, des requêtes fiables, l’authentification, l’isolation des tenants, l’observabilité et des outils testés rendent la couche de langage suffisamment digne de confiance.

Considérez le modèle comme une interface et un composant de raisonnement, pas comme la plateforme de données ni la frontière de sécurité. Gardez les faits dans les systèmes de référence, les calculs dans les services déterministes, les autorisations dans des contrôles de confiance et le contexte fourni au modèle aussi limité et explicite que la tâche le permet.

Étiquettes

  • IA
  • LLM
  • Python
  • Azure