Strukturierte Ausgabe für hybride Funktionen in Web-Apps generieren

Gemini-Modelle geben Antworten standardmäßig als unstrukturierten Text zurück. Für einige Anwendungsfälle ist jedoch strukturierter Text (z. B. JSON oder Enums) erforderlich. Möglicherweise verwenden Sie die Antwort für andere nachgelagerte Aufgaben, für die ein etabliertes Datenschema erforderlich ist.

Damit die vom Modell generierte Ausgabe immer einem bestimmten Schema entspricht, können Sie ein Schema definieren, das als Vorlage für Modellantworten dient. Sie können dann Daten direkt aus der Ausgabe des Modells extrahieren, ohne dass eine umfangreiche Nachbearbeitung erforderlich ist.

Hier ein paar Anwendungsbeispiele:

  • Sorgen Sie dafür, dass die Antwort eines Modells gültiges JSON erzeugt und Ihrem bereitgestellten Schema entspricht.
    Das Modell kann beispielsweise strukturierte Einträge für Rezepte generieren, die immer den Rezeptnamen, die Zutatenliste und die Zubereitungsschritte enthalten. Anschließend können Sie diese Informationen leichter parsen und in der Benutzeroberfläche Ihrer App anzeigen.

  • Einschränken, wie ein Modell bei Klassifizierungsaufgaben reagieren kann
    Sie können das Modell beispielsweise Text mit einer bestimmten Gruppe von Labels annotieren lassen (z. B. eine bestimmte Gruppe von Enums wie positive und negative) anstelle von Labels, die das Modell generiert (die eine gewisse Variabilität aufweisen können, z. B. good, positive, negative oder bad).

Auf dieser Seite wird beschrieben, wie Sie strukturierte Ausgaben (z. B. JSON und Enums) in Ihren hybriden Benutzeroberflächen für Web-Apps generieren.

 Zur JSON-Ausgabe springen  Zur Enum-Ausgabe springen

Konfiguration für strukturierte Ausgabe

Die Generierung strukturierter Ausgaben (wie JSON und Enums) wird für die Inferenz sowohl mit cloudbasierten als auch mit On-Device-Modellen unterstützt.

  • Hybride Inferenzmodi: Konfigurieren Sie sowohl inCloudParams als auch onDeviceParams, damit das Modell mit strukturierter Ausgabe reagiert, unabhängig davon, ob die Inferenz in der Cloud oder auf dem Gerät ausgeführt wird:

    • Für On-Device-Modelle: Geben Sie die responseConstraint in onDeviceParams an. Verwenden Sie dazu entweder ein Schema, das mit Schema-Hilfsmethoden erstellt wurde, oder ein einfaches JSON-Schema.

    • Für cloudgehostete Modelle: Geben Sie responseMimeType (application/json für JSON oder text/x.enum für Enums) und responseSchema in inCloudParams an.

  • Nicht hybride Inferenzmodi: Verwenden Sie nur die oben beschriebene Konfiguration.

Hinweis

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Achten Sie darauf, dass Sie den Startleitfaden für die Entwicklung hybrider Erlebnisse durchgearbeitet haben.


 Zur JSON-Ausgabe springen  Zur Enum-Ausgabe springen

JSON-Ausgabe

In den folgenden Beispielen wird das allgemeine Beispiel für die JSON-Ausgabe an die hybride Inferenz angepasst (z. B. PREFER_ON_DEVICE).

In diesem Szenario generiert das Modell eine Liste von Charakterprofilen für eine Fantasy-Geschichte mit strukturierten Attributen wie Name, Alter, Spezies und optionalem Zubehör.

Sie können Ihre Antwortschemata mit einem der folgenden Ansätze definieren:

  • Firebase-Schema-Hilfsmethoden (empfohlen): Verwenden Sie Hilfsmethoden wie Schema.object() und Schema.enumString(), um prägnante, kompakte Schemas direkt in Ihren Code zu schreiben, ohne zusätzlichen Boilerplate-Code.

  • Einfaches JSON-Schema: Verwenden Sie ein Standard-JSON-Schemaobjekt, wenn Sie bereits Schemadefinitionen haben, Schemas plattform- oder backendübergreifend freigeben oder Schemas aus JSON-Dateien importieren möchten.

Beispiel 1: Firebase-Schema-Hilfsmethoden verwenden

In diesem Beispiel werden Schema-Hilfsmethoden wie Schema.object, Schema.array, Schema.string und Schema.number verwendet, die vom Firebase AI Logic-SDK bereitgestellt werden, um das Objektschema zu definieren.

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden. 

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()));

Beispiel 2: Einfaches JSON-Schema verwenden

In diesem Beispiel wird das Schema nur mit JSON definiert.

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden. 

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()));

Enum-Ausgabe

In den folgenden Beispielen wird das allgemeine Beispiel für die Enum-Ausgabe an die hybride Inferenz angepasst (z. B. PREFER_ON_DEVICE).

In den Beispielen klassifiziert das Modell eine Filmbeschreibung, indem es ein einzelnes Genre aus einer vordefinierten Liste zulässiger Optionen (drama, comedy oder documentary) auswählt.

Sie können Ihre Antwortschemata mit einem der folgenden Ansätze definieren:

  • Firebase-Schema-Hilfsmethoden (empfohlen): Verwenden Sie Hilfsmethoden wie Schema.object() und Schema.enumString(), um prägnante, kompakte Schemas direkt in Ihren Code zu schreiben, ohne zusätzlichen Boilerplate-Code.

  • Einfaches JSON-Schema: Verwenden Sie ein Standard-JSON-Schemaobjekt, wenn Sie bereits Schemadefinitionen haben, Schemas plattform- oder backendübergreifend verwenden oder Schemas aus JSON-Dateien importieren möchten.

Beispiel 1: Firebase-Schema-Hilfsmethoden verwenden

In diesem Beispiel wird die Hilfsmethode Schema.enumString verwendet, die vom Firebase AI Logic SDK bereitgestellt wird, um zulässige Enum-Werte zu definieren.

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden. 

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());

Beispiel 2: Einfaches JSON-Schema verwenden

In diesem Beispiel wird das Enum-Schema nur mit JSON definiert.

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden. 

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());


Feedback zu Firebase AI Logic geben