Strukturierte Ausgabe mit der Gemini API generieren

Python Node.js Go Dart (Flutter) Android Swift Web REST

Gemini generiert standardmäßig unstrukturierten Text, für einige Anwendungen ist jedoch strukturierter Text erforderlich. Für diese Anwendungsfälle können Sie Gemini dazu veranlassen, mit JSON zu antworten, einem strukturierten Datenformat, das für die automatisierte Verarbeitung geeignet ist. Sie können das Modell auch so einschränken, dass es mit einer der in einem Enum angegebenen Optionen antwortet.

Hier sind einige Anwendungsfälle, für die eine strukturierte Ausgabe des Modells erforderlich sein kann:

• Erstellen Sie eine Datenbank mit Unternehmen, indem Sie Unternehmensinformationen aus Zeitungsartikeln extrahieren.
• Standardisierte Informationen aus Lebensläufen extrahieren
• Zutaten aus Rezepten extrahieren und für jede Zutat einen Link zu einer Lebensmittelwebsite anzeigen.

Sie können Gemini in Ihrem Prompt auffordern, eine JSON-formatierte Ausgabe zu erstellen. Es kann jedoch nicht garantiert werden, dass das Modell ausschließlich JSON-Daten zurückgibt. Für eine deterministischere Antwort können Sie ein bestimmtes JSON-Schema in einem responseSchema-Feld übergeben, damit Gemini immer mit einer erwarteten Struktur antwortet. Weitere Informationen zum Arbeiten mit Schemas finden Sie unter Weitere Informationen zu JSON-Schemas.

In diesem Leitfaden erfahren Sie, wie Sie JSON mit der Methode generateContent über das SDK Ihrer Wahl oder direkt über die REST API generieren. In den Beispielen ist nur Text zu sehen. Gemini kann jedoch auch JSON-Antworten auf multimodale Anfragen generieren, die Bilder, Videos und Audio enthalten.

Bevor Sie beginnen: Projekt und API-Schlüssel einrichten

Bevor Sie die Gemini API aufrufen können, müssen Sie Ihr Projekt einrichten und Ihren API-Schlüssel konfigurieren.

JSON generieren

Wenn das Modell für die Ausgabe von JSON konfiguriert ist, antwortet es auf jeden Prompt mit einer JSON-formatierten Ausgabe.

Sie können die Struktur der JSON-Antwort durch Angabe eines Schemas steuern. Es gibt zwei Möglichkeiten, dem Modell ein Schema zur Verfügung zu stellen:

• Als Text im Prompt
• Als strukturiertes Schema, das über die Modellkonfiguration bereitgestellt wird

Schema als Text im Prompt angeben

Im folgenden Beispiel wird das Modell aufgefordert, Keksrezepte im JSON-Format zurückzugeben.

Da das Modell die Formatspezifikation aus dem Text im Prompt erhält, haben Sie bei der Darstellung der Spezifikation etwas Spielraum. Jedes vernünftige Format für die Darstellung eines JSON-Schemas kann funktionieren.

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
});

const prompt = `List a few popular cookie recipes using this JSON schema:

Recipe = {'recipeName': string}
Return: Array<Recipe>`;

const result = await model.generateContent(prompt);
console.log(result.response.text());
controlled_generation.js

Die Ausgabe könnte in etwa so aussehen:

[{"recipeName": "Chocolate Chip Cookies"}, {"recipeName": "Oatmeal Raisin Cookies"}, {"recipeName": "Snickerdoodles"}, {"recipeName": "Sugar Cookies"}, {"recipeName": "Peanut Butter Cookies"}]

Schema über die Modellkonfiguration angeben

Im folgenden Beispiel geschieht Folgendes:

1. Erzeugt ein Modell, das über ein Schema konfiguriert wurde, um mit JSON zu antworten.
2. Das Modell wird aufgefordert, Keksrezepte zurückzugeben.

Diese formellere Methode zur Deklaration des JSON-Schemas bietet eine genauere Kontrolle als nur der Text im Prompt.

// Make sure to include these imports:
// import { GoogleGenerativeAI, SchemaType } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

const schema = {
  description: "List of recipes",
  type: SchemaType.ARRAY,
  items: {
    type: SchemaType.OBJECT,
    properties: {
      recipeName: {
        type: SchemaType.STRING,
        description: "Name of the recipe",
        nullable: false,
      },
    },
    required: ["recipeName"],
  },
};

const model = genAI.getGenerativeModel({
  model: "gemini-1.5-pro",
  generationConfig: {
    responseMimeType: "application/json",
    responseSchema: schema,
  },
});

const result = await model.generateContent(
  "List a few popular cookie recipes.",
);
console.log(result.response.text());
controlled_generation.js

Die Ausgabe könnte in etwa so aussehen:

[{"recipeName": "Chocolate Chip Cookies"}, {"recipeName": "Oatmeal Raisin Cookies"}, {"recipeName": "Snickerdoodles"}, {"recipeName": "Sugar Cookies"}, {"recipeName": "Peanut Butter Cookies"}]

Weitere Informationen zu JSON-Schemas

Wenn Sie das Modell so konfigurieren, dass es eine JSON-Antwort zurückgibt, können Sie mit einem Schema-Objekt die Form der JSON-Daten definieren. Schema ist eine ausgewählte Teilmenge des OpenAPI 3.0-Schemaobjekts.

Hier ist eine Pseudo-JSON-Darstellung aller Schema-Felder:

{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "propertyOrdering": [
    string
  ],
  "items": {
    object (Schema)
  }
}

Der Type des Schemas muss einer der OpenAPI-Datentypen sein. Für jede Type ist nur eine Teilmenge der Felder gültig. In der folgenden Liste wird jeder Type einem gültigen Feld für diesen Typ zugeordnet:

• string –> enum, format
• integer -> Format
• number -> Format
• boolean
• array –> minItems, maxItems, items
• object -> properties, required, propertyOrdering, nullable

Hier sind einige Beispielschemata mit gültigen Kombinationen von Typ und Feld:

{ "type": "string", "enum": ["a", "b", "c"] }

{ "type": "string", "format": "date-time" }

{ "type": "integer", "format": "int64" }

{ "type": "number", "format": "double" }

{ "type": "boolean" }

{ "type": "array", "minItems": 3, "maxItems": 3, "items": { "type": ... } }

{ "type": "object",
  "properties": {
    "a": { "type": ... },
    "b": { "type": ... },
    "c": { "type": ... }
  },
  "nullable": true,
  "required": ["c"],
  "propertyOrdering": ["c", "b", "a"]
}

Eine vollständige Dokumentation der Schemafelder, wie sie in der Gemini API verwendet werden, finden Sie in der Schemareferenz.

Property-Anordnung

Bei der Arbeit mit JSON-Schemas in der Gemini API ist die Reihenfolge der Properties wichtig. Standardmäßig werden die Properties in der API alphabetisch sortiert und die Reihenfolge, in der sie definiert sind, wird nicht beibehalten. Die Google Gen AI SDKs können diese Reihenfolge jedoch beibehalten. Wenn Sie dem Modell Beispiele mit einem konfigurierten Schema zur Verfügung stellen und die Property-Sortierung der Beispiele nicht mit der Property-Sortierung des Schemas übereinstimmt, kann die Ausgabe unzusammenhängend oder unerwartet sein.

Für eine einheitliche, vorhersehbare Sortierung von Unterkünften können Sie das optionale Feld propertyOrdering[] verwenden.

"propertyOrdering": ["recipe_name", "ingredients"]

propertyOrdering[] ist kein Standardfeld in der OpenAPI-Spezifikation. Es ist ein Array von Strings, mit dem die Reihenfolge der Eigenschaften in der Antwort bestimmt wird. Wenn Sie die Reihenfolge der Properties angeben und dann Beispiele mit Properties in derselben Reihenfolge angeben, können Sie die Qualität der Ergebnisse möglicherweise verbessern.