Générer des résultats structurés pour les expériences hybrides dans les applications Web

Par défaut, les modèles Gemini renvoient des réponses sous forme de texte non structuré. Toutefois, certains cas d'utilisation nécessitent du texte structuré (comme JSON ou des énumérations). Par exemple, vous pouvez utiliser la réponse pour d'autres tâches en aval qui nécessitent un schéma de données établi.

Pour vous assurer que la sortie générée du modèle respecte toujours un schéma spécifique, vous pouvez définir un schéma, qui fonctionne comme un plan pour les réponses du modèle. Vous pouvez ensuite extraire directement les données de la sortie du modèle avec moins de post-traitement.

Voici quelques exemples d'utilisation :

  • Assurez-vous que la réponse d'un modèle produit du code JSON valide et qu'elle est conforme au schéma que vous avez fourni.
    Par exemple, le modèle peut générer des entrées structurées pour les recettes qui incluent toujours le nom de la recette, la liste des ingrédients et les étapes. Vous pouvez ensuite analyser et afficher plus facilement ces informations dans l'UI de votre application.

  • Limitez la façon dont un modèle peut répondre lors des tâches de classification.
    Par exemple, vous pouvez demander au modèle d'annoter du texte avec un ensemble spécifique de libellés (par exemple, un ensemble spécifique d'énums comme positive et negative), plutôt qu'avec des libellés produits par le modèle (qui peuvent présenter un certain degré de variabilité, comme good, positive, negative ou bad).

Cette page explique comment générer des sorties structurées (comme JSON et des énumérations) dans vos expériences hybrides pour les applications Web.

 Accéder à la sortie JSON  Accéder à la sortie enum

Configuration pour la sortie structurée

La génération de résultats structurés (comme JSON et les énumérations) est compatible avec l'inférence à l'aide de modèles hébergés dans le cloud et sur l'appareil.

  • Modes d'inférence hybrides : configurez inCloudParams et onDeviceParams pour que le modèle réponde avec une sortie structurée, que l'inférence s'exécute dans le cloud ou sur l'appareil :

    • Pour les modèles sur l'appareil : spécifiez responseConstraint dans onDeviceParams à l'aide d'un schéma créé avec les méthodes d'assistance Schema ou d'un schéma JSON simple.

    • Pour les modèles hébergés dans le cloud : spécifiez responseMimeType (application/json pour JSON ou text/x.enum pour les énumérations) et responseSchema dans inCloudParams.

  • Modes d'inférence non hybrides : n'utilisez que la configuration applicable décrite ci-dessus.

Avant de commencer

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Assurez-vous d'avoir suivi le guide de démarrage pour créer des expériences hybrides.


 Accéder à la sortie JSON  Accéder à la sortie enum

Sortie JSON

Les exemples suivants adaptent l'exemple général de sortie JSON pour tenir compte de l'inférence hybride (par exemple, PREFER_ON_DEVICE).

Dans le scénario de ces exemples, le modèle génère une liste de profils de personnages pour une histoire fantastique, avec des attributs structurés tels que le nom, l'âge, l'espèce et les accessoires facultatifs.

Vous pouvez définir vos schémas de réponse à l'aide de l'une des approches suivantes :

  • Méthodes d'assistance Firebase Schema (recommandé) : Utilisez des méthodes d'assistance (telles que Schema.object() et Schema.enumString()) pour écrire des schémas concis et compacts directement dans votre code, sans code passe-partout supplémentaire.

  • Schéma JSON brut : utilisez un objet de schéma JSON standard si vous disposez déjà de définitions de schéma, si vous partagez des schémas entre des plates-formes ou des services de backend, ou si vous importez des schémas à partir de fichiers JSON.

Exemple 1 : Utiliser les méthodes d'assistance Firebase Schema

Cet exemple utilise les méthodes d'assistance Schema (telles que Schema.object, Schema.array, Schema.string et Schema.number) fournies par le SDK Firebase AI Logic pour définir le schéma d'objet.

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode,
  Schema
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define a schema using the `Schema` helper methods.
// Optional properties are specified in optionalProperties.
const jsonSchema = Schema.object({
  properties: {
    characters: Schema.array({
      items: Schema.object({
        properties: {
          name: Schema.string(),
          age: Schema.number(),
          species: Schema.string(),
          accessory: Schema.string()
        },
        optionalProperties: ["accessory"]
      })
    })
  }
});

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    }
  },
  // For on-device models, pass the schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});

const prompt = "Create profiles for some characters for a fantasy story.";

// Generate the structured output.
const result = await model.generateContent(prompt);

// Access the generated JSON string conforming to the schema from response.text().
console.log(result.response.text());

// Parse the JSON string into a JavaScript object.
console.log(JSON.parse(result.response.text()));

Exemple 2 : Utiliser un schéma JSON simple

Cet exemple définit le schéma en utilisant uniquement JSON.

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define the schema as a plain JSON object.
// Properties are required by default unless omitted from the required array.
const jsonSchema = {
  type: "object",
  properties: {
    characters: {
      type: "array",
      items: {
        type: "object",
        properties: {
          name: {
            type: "string",
            nullable: false
          },
          age: {
            type: "number",
            nullable: false
          },
          species: {
            type: "string",
            nullable: false
          },
          accessory: {
            type: "string",
            nullable: true
          }
        },
        nullable: false,
        required: [
          "name",
          "age",
          "species"
        ]
      },
      nullable: false
    }
  },
  nullable: false,
  required: [
    "characters"
  ]
};

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    }
  },
  // For on-device models, pass the schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});

const prompt = "Create profiles for some characters for a fantasy story.";

// Generate the structured output.
const result = await model.generateContent(prompt);

// Access the generated JSON string conforming to the schema from response.text().
console.log(result.response.text());

// Parse the JSON string into a JavaScript object.
console.log(JSON.parse(result.response.text()));

Sortie enum

Les exemples suivants adaptent l'exemple général de sortie enum pour tenir compte de l'inférence hybride (par exemple, PREFER_ON_DEVICE).

Dans le scénario de ces exemples, le modèle classe une description de film en sélectionnant un seul genre dans une liste prédéfinie d'options autorisées (drama, comedy ou documentary).

Vous pouvez définir vos schémas de réponse à l'aide de l'une des approches suivantes :

  • Méthodes d'assistance Firebase Schema (recommandé) : Utilisez des méthodes d'assistance (telles que Schema.object() et Schema.enumString()) pour écrire des schémas concis et compacts directement dans votre code, sans code passe-partout supplémentaire.

  • Schéma JSON brut : utilisez un objet de schéma JSON standard si vous disposez déjà de définitions de schéma, si vous partagez des schémas entre des plates-formes ou des services de backend, ou si vous importez des schémas à partir de fichiers JSON.

Exemple 1 : Utiliser les méthodes d'assistance Firebase Schema

Cet exemple utilise la méthode d'assistance Schema.enumString fournie par le SDK Firebase AI Logic pour définir les valeurs d'énumération autorisées.

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode,
  Schema
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define an enum schema using the `Schema` helper method with allowed string values.
const enumSchema = Schema.enumString({
  enum: ["drama", "comedy", "documentary"]
});

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    }
  },
  // For on-device models, pass the enum schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: enumSchema
    }
  }
});

const prompt = `The film aims to educate and inform viewers about real-life
subjects, events, or people. It offers a factual record of a particular topic
by combining interviews, historical footage, and narration. The primary purpose
of a film is to present information and provide insights into various aspects
of reality.`;

// Generate the structured enum output.
const result = await model.generateContent(prompt);

// Access the selected enum value string from response.text().
console.log(result.response.text());

Exemple 2 : Utiliser un schéma JSON simple

Cet exemple définit le schéma enum à l'aide de JSON uniquement.

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. 

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  InferenceMode
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration.
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp.
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Define the enum schema as a plain JSON object.
const enumSchema = {
  type: "string",
  enum: ["drama", "comedy", "documentary"]
};

// Create a GenerativeModel instance configured to use a hybrid inference mode (like PREFER_ON_DEVICE).
const model = getGenerativeModel(ai, {
  mode: InferenceMode.INFERENCE_MODE,
  // For cloud-hosted models, specify MIME type and response schema.
  inCloudParams: {
    model: "CLOUD_MODEL_NAME",
    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    }
  },
  // For on-device models, pass the enum schema as the response constraint.
  onDeviceParams: {
    promptOptions: {
      responseConstraint: enumSchema
    }
  }
});

const prompt = `The film aims to educate and inform viewers about real-life
subjects, events, or people. It offers a factual record of a particular topic
by combining interviews, historical footage, and narration. The primary purpose
of a film is to present information and provide insights into various aspects
of reality.`;

// Generate the structured enum output.
const result = await model.generateContent(prompt);

// Access the selected enum value string from response.text().
console.log(result.response.text());


Envoyer des commentaires sur votre expérience avec Firebase AI Logic