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

Les modèles Gemini renvoient par défaut des réponses sous forme de texte non structuré. Cependant, 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 par le modèle respecte toujours un schéma spécifique, vous pouvez définir un schéma, qui fonctionne comme un modèle 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 :

  • S'assurer 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 des 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'interface utilisateur de votre application.

  • Limiter 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 d'étiquettes (par exemple, un ensemble spécifique d'énumérations telles que positive et negative), plutôt qu'avec des étiquettes produites par le modèle (qui pourraient présenter un certain degré de variabilité, comme good, positive, negative ou bad).

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

 Accéder à la sortie JSON  Accéder à la sortie d'énumération

Configuration de 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 à la fois 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 le responseConstraint dans onDeviceParams à l'aide d'un schéma créé avec les méthodes d'assistance Schema ou d'un schéma JSON brut.

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

  • Modes d'inférence non hybrides : utilisez uniquement 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 au 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 d'énumération

Sortie JSON

Les exemples suivants adaptent l'exemple de sortie JSON général pour prendre en charge 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 récurrent 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 les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton correspondant au 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 brut

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

Avant d'essayer cet exemple, suivez les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton correspondant au 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 d'énumération

Les exemples suivants adaptent l'exemple de sortie d'énumération générale pour prendre en compte 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 récurrent 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 les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton correspondant au 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 brut

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

Avant d'essayer cet exemple, suivez les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton correspondant au 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