Rendre l’IA prévisible : le rôle clé du schéma JSON

L’IA est de plus en plus présente dans nos applications. Elle peut générer des fichiers JSON complexes, extraire des données de documents ou fournir des réponses structurées. Mais il y a un problème : l’IA peut commettre des erreurs, omettre des champs, voire inventer des informations.

C’est là qu’un schéma JSON devient indispensable. Il sert de cadre pour vérifier que les réponses de l’IA respectent strictement la structure attendue, garantissant ainsi que vos données restent fiables et utilisables dans vos applications 4D.

Pourquoi le schéma JSON est-il important lors de l’utilisation de l’IA

Un schéma JSON vous permet de :

• De valider automatiquement les réponses produites par l’IA
• Détecter les erreurs, les incohérences ou les champs manquants
• Renvoyer ces erreurs à l’IA pour une correction automatique
• De garantir des données exploitables, même si le modèle évolue ou commet des erreurs

En pratique, le schéma agit comme un filet de sécurité : vous continuez à bénéficier de la puissance de l’IA tout en conservant un format prévisible et contrôlé pour vos applications 4D.

Utilisation de JSON Schema avec 4D AI Kit

4D AI Kit inclut une fonctionnalité très utile : la possibilité de demander à l’IA de renvoyer une réponse JSON structurée selon un schéma spécifique.

Cela vous permet de définir exactement :

• les champs attendus,
• leurs types,
• et même certaines contraintes (valeurs autorisées, plages numériques, etc.).

Cette approche est détaillée dans deux articles du blog 4D : l’un consacré aux sorties structurées, qui demandent explicitement à l’IA de se conformer à un format de réponse prédéfini, et l’autre présentant le parseur JSON Schema Draft 2020-12, qui prend en charge la dernière norme et permet une validation plus stricte et plus expressive du JSON généré par l’IA.

Exemple : analyse de texte et extraction d’entités

Imaginez que vous utilisiez une API d’analyse de texte pour reconnaître des entités dans une phrase. Une réponse de l’IA pourrait ressembler à ceci :

{
  "model": "gpt-text-analyzer-v2",
  "input": "Steve Jobs a fondé Apple à Cupertino.",
  "entities": [
    { "type": "PERSON", "text": "Steve Jobs", "confidence": 0.98 },
    { "type": "ORG", "text": "Apple", "confidence": 0.95 },
    { "type": "LOCATION", "text": "Cupertino", "confidence": 0.93 }
  ]
}

Le schéma JSON de validation

Pour vous assurer que l’IA respecte cette structure, vous pouvez définir un schéma JSON compatible avec la version préliminaire 2020-12 :

{
  "$schema": "https://json-schema.org/draft/2020-12/schema#",
  "title": "Réponse de l'analyse de texte par IA",
  "type": "object",
  "properties": {
    "model": { "type": "string" },
    "input": { "type": "string" },
    "entities": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": { "type": "string", "enum": ["PERSON", "ORG", "LOCATION"] },
          "text": { "type": "string" },
          "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
        },
        "required": ["type", "text", "confidence"]
      }
    }
  },
  "required": ["model", "input", "entities"]
}

Ce schéma garantit la structure des données renvoyées par l’IA. JSON Schema ne valide pas la pertinence sémantique des réponses, mais il impose un cadre strict qui permet à vos applications 4D de fonctionner avec des données fiables et exploitables.

L’invite système : définir le comportement de l’IA

La consigne système est essentielle. Elle définit le rôle de l’IA et impose une discipline stricte quant au format de sortie.

Vous êtes un moteur d'analyse de texte IA.

Votre tâche consiste à analyser le texte fourni et à extraire les entités nommées.

Vous devez identifier :
- les personnes (PERSON)
- les organisations (ORG)
- les lieux (LOCATION)

Renvoyez le résultat strictement sous la forme d’un objet JSON conforme au schéma JSON fourni.
N’ajoutez aucun champ supplémentaire.
N’ajoutez pas d’explications ou de texte en dehors du JSON.
Si aucune entité n’est trouvée, renvoyez un tableau vide pour « entities ».

Cette consigne :

• définit clairement la tâche,
• réitère explicitement les contraintes,
• limite fortement les écarts créatifs par rapport au modèle.

Implémentation avec 4D AI Kit

Voyons maintenant comment implémenter ce mécanisme du côté 4D à l’aide du 4D AI Kit.

Configuration du chat et du schéma

Dans cet exemple, le schéma JSON et l’invite du système sont stockés dans les ressources de l’application et transmis explicitement au modèle lors de l’appel.

// Retrieve the system prompt
var $systemPrompt:=File("/RESOURCES/prompt.txt").getText()
// Retrieve the JSON Schema to validate the AI response
var $schema:=JSON Parse(File("/RESOURCES/schema.json").getText())
// Define chat parameters
var $params:=cs.AIKit.OpenAIChatCompletionsParameters.new()
$params.model:="gpt-text-analyzer-v2"
$params.response_format:={\
   type: "json_schema"; \
   json_schema: {name: "analyse_schema"; schema: $schema}}
// Create AI chat helper
var $ai:=cs.AIKit.OpenAI.new($openAIKey)
var $chatHelper:=$ai.chat.create($systemPrompt; $params)

Grâce à cette configuration, l’IA sait exactement quel format elle doit produire, ce qui réduit considérablement les erreurs.

Appel de l’IA

Une fois le schéma et le format de réponse configurés, il ne reste plus qu’à appeler l’IA et à lui fournir le texte à analyser.

// Send the user prompt to the AI
var $userPrompt:="Steve Jobs founded Apple in Cupertino."
var $result:=$chatHelper.prompt($userPrompt)
// Convert AI response to object
var $response:=JSON Parse($result.choice.message.text)

Validation de la réponse de l’IA et gestion des erreurs

Même lorsqu’un schéma est fourni, il est essentiel de valider la réponse côté 4D avant de l’utiliser. L’IA peut produire une réponse non valide en raison d’une troncature, d’erreurs de génération ou d’un contexte ambigu.

// Validate the JSON against the schema
var $validation:=JSON Validate($response; $schema)
// Handle validation errors
If (Not($validation.success))
   // If the JSON is invalid, build an error prompt to send back to the AI
   var $errorPrompt:=\
      "The JSON you returned does not match the expected schema. "+\
      "Here are the validation errors:\n"+\
      JSON Stringify($validation.errors)+\
      "\nPlease return a corrected JSON that strictly follows the schema."
   // Resend the prompt (or send error prompt) to let AI correct its output
   $result:=$chatHelper.prompt($userPrompt)
Else
   // If the JSON is valid, continue with your processing
   // e.g., save to database, display in form, or trigger further actions
End if

Ce mécanisme permet de mettre en place une boucle IA → 4D → IA :

1. L’IA génère une réponse JSON.
2. 4D valide le JSON par rapport au schéma.
3. Si une erreur est détectée, 4D renvoie les informations manquantes ou incorrectes à l’IA.
4. L’IA corrige la réponse et renvoie un JSON valide.

Cette boucle de rétroaction automatique garantit la fiabilité de vos données, même lorsque l’IA commet des erreurs.

Avantages concrets

• Un JSON généré par l’IA qui est fiable et cohérent
• Correction automatique des erreurs grâce à la boucle de validation
• Sécurité et contrôle sur l’ensemble de vos pipelines API → IA
• Des données toujours exploitables pour vos formulaires, votre traitement ou vos analyses

Conclusion

L’intégration de JSON Schema à 4D AI Kit transforme votre utilisation de l’IA. Vous passez d’un workflow « IA imprévisible » à un processus prévisible, contrôlé, robuste et automatisé.

En combinant les sorties structurées, JSON Schema et la validation côté 4D, vous exploitez pleinement la puissance de l’IA tout en garantissant des données fiables, sécurisées et prêtes pour la production.

Cette approche va bien au-delà de la simple analyse de texte. Le même modèle peut être appliqué à tout scénario où des données générées par l’IA doivent être intégrées en toute sécurité dans une application 4D.

Le schéma JSON ne rend pas l’IA « intelligente », mais il la rend prévisible.