Skip to content
Learni
Voir tous les tutoriels
Intelligence Artificielle

Comment utiliser les sorties structurées JSON Schema en 2026

12 minBEGINNER
TypeScriptOpenAIJSON Schema
Read in English

Introduction

Les sorties structurées permettent d'obtenir des réponses d'IA toujours conformes à un format précis via JSON Schema. Cette approche élimine les erreurs de parsing et garantit des données exploitables immédiatement. En 2026, elle est devenue indispensable pour les applications professionnelles qui intègrent des modèles de langage. Ce tutoriel vous guide pas à pas pour implémenter cette fonctionnalité avec OpenAI et TypeScript.

Prérequis

  • Node.js 20+
  • Compte OpenAI avec clé API
  • Connaissances basiques de TypeScript
  • npm ou pnpm installé

Installation des dépendances

terminal
npm install openai zod
npm install -D @types/node typescript

On installe le SDK OpenAI officiel et Zod pour la validation de schéma. Ces packages permettent de définir et valider facilement les structures de données attendues.

Définir le schéma JSON

schemas/user.ts
import { z } from 'zod';

export const UserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email(),
  age: z.number().int().min(18),
  interests: z.array(z.string()).max(5)
});

export type User = z.infer<typeof UserSchema>;

Ce schéma Zod définit la structure attendue. Il sera converti en JSON Schema pour l'API OpenAI et permet une validation stricte côté client.

Configuration du client OpenAI

lib/openai.ts
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

export default openai;

Initialisation du client avec la clé API stockée dans les variables d'environnement. Toujours utiliser des variables d'environnement pour les clés sensibles.

Appel avec structured outputs

lib/generateUser.ts
import openai from './openai';
import { UserSchema } from '../schemas/user';

export async function generateUser(prompt: string) {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4o-2024-08-06',
    messages: [{ role: 'user', content: prompt }],
    response_format: {
      type: 'json_schema',
      json_schema: {
        name: 'user',
        schema: UserSchema,
        strict: true
      }
    }
  });

  return UserSchema.parse(JSON.parse(completion.choices[0].message.content!));
}

L'option response_format avec json_schema force le modèle à respecter exactement le schéma. Le flag strict garantit une conformité totale sans déviation.

Utilisation dans une route API

app/api/user/route.ts
import { generateUser } from '@/lib/generateUser';
import { NextResponse } from 'next/server';

export async function POST(req: Request) {
  const { prompt } = await req.json();
  const user = await generateUser(prompt);
  return NextResponse.json(user);
}

Exemple d'intégration dans une API Next.js. La fonction retourne directement un objet typé et validé prêt à être consommé par le frontend.

Bonnes pratiques

  • Toujours activer le mode strict pour garantir la conformité
  • Utiliser des descriptions claires dans le schéma
  • Limiter la taille du schéma pour réduire les coûts
  • Valider les données côté client avec Zod après réception
  • Versionner vos schémas pour les évolutions de modèle

Erreurs courantes à éviter

  • Oublier le flag strict qui permet des réponses non conformes
  • Définir des schémas trop complexes qui font échouer l'appel
  • Ne pas gérer les erreurs de validation Zod
  • Exposer la clé API dans le code frontend

Pour aller plus loin

Découvrez nos formations avancées sur l'intégration d'IA structurée : https://learni-group.com/formations