Comment nous utilisons l'IA pour corriger les données chez Swiftgum

Le défi de l'intégrité des données

Chez Swiftgum, la qualité des données est cruciale. Face à des flux de données complexes, les erreurs sont inévitables. Au lieu de rejeter les données incorrectes ou de passer des heures à les corriger manuellement, nous avons créé une approche innovante. Notre solution combine les schémas JSON et l'IA pour automatiser la correction des erreurs. Voici comment ça marche.

Les schémas : la base d'une bonne qualité de données

Avant de corriger, il faut définir ce qu'est une donnée "correcte". Un schéma décrit la structure attendue des données. Il précise les champs nécessaires, leur type (texte, nombre, etc.), et peut inclure des règles de validation plus poussées.

Pourquoi utiliser des schémas ?

Les schémas sont essentiels pour plusieurs raisons :

• Ils permettent de vérifier automatiquement si les données sont conformes
• Ils assurent une structure uniforme des données dans tous nos systèmes
• Ils définissent clairement comment les différents services doivent échanger des informations

JSON Schema : simple et efficace

Nous utilisons JSON Schema, un standard ouvert pour décrire la structure des données JSON. Voici un exemple adapté à notre domaine immobilier :

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "BailCommercial",
  "description": "Données extraites d'un bail commercial",
  "type": "object",
  "properties": {
    "preneur": {
      "type": "string",
      "description": "Nom de l'entreprise locataire"
    },
    "loyer_annuel": {
      "type": "number",
      "minimum": 0,
      "description": "Loyer annuel en euros"
    },
    "date_effet": {
      "type": "string",
      "format": "date",
      "description": "Date de prise d'effet du bail"
    },
    "duree": {
      "type": "integer",
      "minimum": 1,
      "description": "Durée du bail en années"
    }
  },
  "required": ["preneur", "loyer_annuel", "date_effet"]
}

Ce schéma indique qu'un bail commercial doit avoir un preneur, un loyer_annuel et une date_effet. La duree est optionnelle mais doit être un nombre entier positif.

Notre bibliothèque interne @swiftgum/schemas, basée sur AJV, utilise ce standard pour définir et valider les données.

Notre processus de correction : fixValueWithAI

Quand des données ne respectent pas le schéma, notre fonction fixValueWithAI entre en jeu.

Étape 1 : Validation initiale

On commence par vérifier si les données respectent le schéma JSON.

// Version simplifiée de notre processus de validation
interface ValidationResult {
  valid: boolean;
  value?: unknown; // Valeur validée si succès
  error?: AjvError; // Erreurs détaillées si échec
}
 
function safeValidate(schema: Schema, value: unknown): ValidationResult {
  // Utilisation d'AJV pour la validation
  const isValid = ajv.validate(schema, value);
  if (isValid) {
    return { valid: true, value: value };
  } else {
    return { valid: false, error: transformAjvErrors(ajv.errors) };
  }
}

• Si les données sont conformes, on les retourne directement
• Sinon, on passe à l'étape suivante avec l'IA

Étape 2 : L'IA à la rescousse

A. Préparation des instructions pour l'IA

Pour que l'IA corrige efficacement, elle a besoin d'informations précises. On crée un message qui contient :

1. Le schéma JSON cible : la structure que les données devraient avoir

2. Les données originales avec erreurs : ce qu'on a reçu

3. Les erreurs détectées : pourquoi les données sont incorrectes. Par exemple :

   [
     {
       "path": "/loyer_annuel",
       "message": "doit être un nombre, mais trouvé : chaîne de caractères",
       "value": "15000 euros"
     },
     {
       "path": "/date_effet",
       "message": "format de date invalide",
       "value": "01/01/22"
     }
   ]

4. Instructions claires : ce que l'IA doit faire

   • Analyser le schéma, les données originales et les erreurs
   • Fournir des données corrigées qui respectent le schéma
   • Ne pas inventer de nouvelles valeurs
   • Si impossible à corriger, répondre simplement {"cannotFix": true}

Un point crucial que nous avons appris : quand nous envoyons le schéma à l'IA, nous utilisons une fonction stripInternalProperties pour retirer toute information non essentielle. Cela rend le prompt plus léger et aide l'IA à se concentrer sur l'essentiel.

B. Dialogue avec l'IA

Nous utilisons un modèle d'OpenAI (actuellement gpt-4o-mini-2024-07-18) via le SDK AI de Vercel.

C. Vérification de la réponse

Une fois la proposition de l'IA reçue :

1. On vérifie si l'IA a répondu {"cannotFix": true}, ce qui signifie qu'elle ne peut pas corriger sans inventer des données

   // Schéma Zod pour la "porte de sortie"
   const EscapeHatchOutputSchema = z.object({
     cannotFix: z.literal(true),
   });
    
   const escapeParseResult = EscapeHatchOutputSchema.safeParse(aiOutput);
   if (escapeParseResult.success) {
     // L'IA signale qu'elle ne peut pas corriger
     throw new Error("L'IA ne peut pas corriger la valeur défectueuse.");
   }

2. Si elle propose une correction, on vérifie à nouveau avec notre schéma JSON

Étape 3 : Plusieurs essais si nécessaire

La correction parfaite du premier coup est rare.

• Notre système fait jusqu'à 2 tentatives par défaut
• Si la première correction n'est pas valide, on réessaie avec cette première tentative comme point de départ
• Cela permet d'améliorer progressivement la correction

Cette approche récursive est particulièrement efficace. Par exemple, lors de la première passe, l'IA pourrait corriger le format d'une date mais manquer une autre erreur. La deuxième passe lui permet de corriger les erreurs restantes, avec un document déjà partiellement amélioré.

Étape 4 : Gestion des échecs

Si après toutes les tentatives les données restent invalides :

• On enregistre l'erreur pour une intervention humaine
• On signale clairement l'échec

Un exemple concret dans l'immobilier

Prenons un cas réel de correction de données d'un bail commercial. Voici des données extraites par OCR avec des erreurs :

{
  "preneur": "SCI Les Oliviers",
  "loyer_annuel": "25 000€ HT/HC",
  "date_effet": "premier janvier 2023",
  "duree": "3+6+9"
}

L'IA identifie et corrige plusieurs problèmes :

1. Le loyer contient du texte au lieu d'être un nombre
2. La date n'est pas au format standard
3. La durée utilise une notation spécifique à l'immobilier

La version corrigée devient :

{
  "preneur": "SCI Les Oliviers",
  "loyer_annuel": 25000,
  "date_effet": "2023-01-01",
  "duree": 3
}

Cette approche est également utilisée dans notre outil d'analyse de baux commerciaux et notre système d'extraction d'informations des baux.

Les technologies utilisées

Notre solution combine plusieurs outils performants :

• Modèles GPT d'OpenAI : pour l'analyse et la correction intelligente
• SDK AI de Vercel : pour l'intégration avec les modèles de langage
• Notre bibliothèque @swiftgum/schemas : pour gérer les schémas JSON
• JSON Schema : standard pour définir les structures de données
• Zod : pour valider les réponses de l'IA

Les avantages de notre approche

Cette méthode offre plusieurs bénéfices :

• Moins d'interventions manuelles : les erreurs courantes sont corrigées automatiquement
• Meilleure qualité des données : plus de conformité aux schémas
• Corrections fiables : l'IA est guidée par des instructions précises
• Contrôle optimal : l'IA est un outil, mais les schémas restent la référence
• Gestion des cas complexes : plus flexible que des corrections codées en dur
• Robustesse : les tentatives multiples augmentent les chances de succès

Ce que nous avons appris

Ce projet nous a enseigné plusieurs leçons :

1. L'importance de la "porte de sortie" : Permettre à l'IA de répondre {"cannotFix": true} évite les corrections hasardeuses. Mieux vaut pas de correction qu'une mauvaise correction.

2. Les avantages de JSON Schema :

   • C'est un standard bien compris par les IA
   • Fournir un schéma simplifié améliore la qualité des corrections

3. L'art de formuler les instructions : La clarté et la précision des instructions données à l'IA sont essentielles pour obtenir de bons résultats.

4. La complémentarité validation/IA : L'IA complète la validation par schéma, elle ne la remplace pas.

5. L'importance des essais multiples : Permettre plusieurs tentatives rend le système plus robuste.

Conclusion : des systèmes plus intelligents

Chez Swiftgum, nous innovons pour améliorer la qualité et la fiabilité. Notre système de correction par IA montre comment nous combinons rigueur technique et intelligence artificielle. Cette approche nous permet de construire des systèmes plus robustes, capables de gérer les défis de la donnée à grande échelle.

Si vous souhaitez voir ces concepts en action, essayez notre outil d'analyse de contrats de location ou consultez notre tutoriel sur l'extraction de données des baux commerciaux.

En partageant notre expérience, nous espérons inspirer d'autres équipes à améliorer leurs processus de gestion des données.