สร้างเอาต์พุตที่มีโครงสร้าง (เช่น JSON และลิสต์แบบจำกัด) โดยใช้ Gemini API

 import FirebaseAI  // Provide a JSON schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. let jsonSchema = Schema.object(   properties: [     "characters": Schema.array(       items: .object(         properties: [           "name": .string(),           "age": .integer(),           "species": .string(),           "accessory": .enumeration(values: ["hat", "belt", "shoes"]),         ],         optionalProperties: ["accessory"]       )     ),   ] )  // Initialize the Gemini Developer API backend service let ai = FirebaseAI.firebaseAI(backend: .googleAI())  // Create a `GenerativeModel` instance with a model that supports your use case let model = ai.generativeModel(   modelName: "gemini-2.5-flash",   // In the generation config, set the `responseMimeType` to `application/json`   // and pass the JSON schema object into `responseSchema`.   generationConfig: GenerationConfig(     responseMIMEType: "application/json",     responseSchema: jsonSchema   ) )  let prompt = "For use in a children's card game, generate 10 animal-based characters."  let response = try await model.generateContent(prompt) print(response.text ?? "No text in response.")  

 // Provide a JSON schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. val jsonSchema = Schema.obj(     mapOf("characters" to Schema.array(         Schema.obj(             mapOf(                 "name" to Schema.string(),                 "age" to Schema.integer(),                 "species" to Schema.string(),                 "accessory" to Schema.enumeration(listOf("hat", "belt", "shoes")),             ),             optionalProperties = listOf("accessory")         )     )) )  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(     modelName = "gemini-2.5-flash",     // In the generation config, set the `responseMimeType` to `application/json`     // and pass the JSON schema object into `responseSchema`.     generationConfig = generationConfig {         responseMimeType = "application/json"         responseSchema = jsonSchema     })  val prompt = "For use in a children's card game, generate 10 animal-based characters." val response = generativeModel.generateContent(prompt) print(response.text)  

 // Provide a JSON schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. Schema jsonSchema = Schema.obj(         /* properties */         Map.of(                 "characters", Schema.array(                         /* items */ Schema.obj(                                 /* properties */                                 Map.of("name", Schema.str(),                                         "age", Schema.numInt(),                                         "species", Schema.str(),                                         "accessory",                                         Schema.enumeration(                                                 List.of("hat", "belt", "shoes")))                         ))),         List.of("accessory"));  // In the generation config, set the `responseMimeType` to `application/json` // and pass the JSON schema object into `responseSchema`. GenerationConfig.Builder configBuilder = new GenerationConfig.Builder(); configBuilder.responseMimeType = "application/json"; configBuilder.responseSchema = jsonSchema;  GenerationConfig generationConfig = configBuilder.build();  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())         .generativeModel(             /* modelName */ "gemini-2.5-flash",             /* generationConfig */ generationConfig); GenerativeModelFutures model = GenerativeModelFutures.from(ai);  Content content = new Content.Builder()     .addText("For use in a children's card game, generate 10 animal-based characters.")     .build();  // For illustrative purposes only. You should use an executor that fits your needs. Executor executor = Executors.newSingleThreadExecutor();  ListenableFuture<GenerateContentResponse> response = model.generateContent(content); Futures.addCallback(     response,     new FutureCallback<GenerateContentResponse>() {       @Override       public void onSuccess(GenerateContentResponse result) {         String resultText = result.getText();         System.out.println(resultText);       }        @Override       public void onFailure(Throwable t) {         t.printStackTrace();       }     },     executor);  

 import { initializeApp } from "firebase/app"; import { getAI, getGenerativeModel, GoogleAIBackend, 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() });  // Provide a JSON schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. const jsonSchema = Schema.object({  properties: {     characters: Schema.array({       items: Schema.object({         properties: {           name: Schema.string(),           accessory: Schema.string(),           age: Schema.number(),           species: Schema.string(),         },         optionalProperties: ["accessory"],       }),     }),   } });  // Create a `GenerativeModel` instance with a model that supports your use case const model = getGenerativeModel(ai, {   model: "gemini-2.5-flash",   // In the generation config, set the `responseMimeType` to `application/json`   // and pass the JSON schema object into `responseSchema`.   generationConfig: {     responseMimeType: "application/json",     responseSchema: jsonSchema   }, });   let prompt = "For use in a children's card game, generate 10 animal-based characters.";  let result = await model.generateContent(prompt) console.log(result.response.text());  

 import 'package:firebase_ai/firebase_ai.dart'; import 'package:firebase_core/firebase_core.dart'; import 'firebase_options.dart';  // Provide a JSON schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. final jsonSchema = Schema.object(         properties: {           'characters': Schema.array(             items: Schema.object(               properties: {                 'name': Schema.string(),                 'age': Schema.integer(),                 'species': Schema.string(),                 'accessory':                     Schema.enumString(enumValues: ['hat', 'belt', 'shoes']),               },             ),           ),         },         optionalProperties: ['accessory'],       );   // Initialize FirebaseApp await Firebase.initializeApp(   options: DefaultFirebaseOptions.currentPlatform, );  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case final model =       FirebaseAI.googleAI().generativeModel(         model: 'gemini-2.5-flash',         // In the generation config, set the `responseMimeType` to `application/json`         // and pass the JSON schema object into `responseSchema`.         generationConfig: GenerationConfig(             responseMimeType: 'application/json', responseSchema: jsonSchema));  final prompt = "For use in a children's card game, generate 10 animal-based characters."; final response = await model.generateContent([Content.text(prompt)]); print(response.text);  

 using Firebase; using Firebase.AI;  // Provide a JSON schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. var jsonSchema = Schema.Object(   properties: new System.Collections.Generic.Dictionary<string, Schema> {     { "characters", Schema.Array(       items: Schema.Object(         properties: new System.Collections.Generic.Dictionary<string, Schema> {           { "name", Schema.String() },           { "age", Schema.Int() },           { "species", Schema.String() },           { "accessory", Schema.Enum(new string[] { "hat", "belt", "shoes" }) },         },         optionalProperties: new string[] { "accessory" }       )     ) },   } );  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case var model = FirebaseAI.DefaultInstance.GetGenerativeModel(   modelName: "gemini-2.5-flash",   // In the generation config, set the `responseMimeType` to `application/json`   // and pass the JSON schema object into `responseSchema`.   generationConfig: new GenerationConfig(     responseMimeType: "application/json",     responseSchema: jsonSchema   ) );  var prompt = "For use in a children's card game, generate 10 animal-based characters.";  var response = await model.GenerateContentAsync(prompt); UnityEngine.Debug.Log(response.Text ?? "No text in response.");  

 import FirebaseAI  // Provide an enum schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. let enumSchema = Schema.enumeration(values: ["drama", "comedy", "documentary"])  // Initialize the Gemini Developer API backend service let ai = FirebaseAI.firebaseAI(backend: .googleAI())  // Create a `GenerativeModel` instance with a model that supports your use case let model = ai.generativeModel(   modelName: "gemini-2.5-flash",   // In the generation config, set the `responseMimeType` to `text/x.enum`   // and pass the enum schema object into `responseSchema`.   generationConfig: GenerationConfig(     responseMIMEType: "text/x.enum",     responseSchema: enumSchema   ) )  let 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. """  let response = try await model.generateContent(prompt) print(response.text ?? "No text in response.")  

 // Provide an enum schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. val enumSchema = Schema.enumeration(listOf("drama", "comedy", "documentary"))  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(     modelName = "gemini-2.5-flash",     // In the generation config, set the `responseMimeType` to `text/x.enum`     // and pass the enum schema object into `responseSchema`.     generationConfig = generationConfig {         responseMimeType = "text/x.enum"         responseSchema = enumSchema     })  val 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.     """ val response = generativeModel.generateContent(prompt) print(response.text)  

 // Provide an enum schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. Schema enumSchema = Schema.enumeration(List.of("drama", "comedy", "documentary"));  // In the generation config, set the `responseMimeType` to `text/x.enum` // and pass the enum schema object into `responseSchema`. GenerationConfig.Builder configBuilder = new GenerationConfig.Builder(); configBuilder.responseMimeType = "text/x.enum"; configBuilder.responseSchema = enumSchema;  GenerationConfig generationConfig = configBuilder.build();  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())         .generativeModel(             /* modelName */ "gemini-2.5-flash",             /* generationConfig */ generationConfig); GenerativeModelFutures model = GenerativeModelFutures.from(ai);  String 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.";  Content content = new Content.Builder().addText(prompt).build();  // For illustrative purposes only. You should use an executor that fits your needs. Executor executor = Executors.newSingleThreadExecutor();  ListenableFuture<GenerateContentResponse> response = model.generateContent(content); Futures.addCallback(     response,     new FutureCallback<GenerateContentResponse>() {       @Override       public void onSuccess(GenerateContentResponse result) {         String resultText = result.getText();         System.out.println(resultText);       }        @Override       public void onFailure(Throwable t) {         t.printStackTrace();       }     },     executor);  

 import { initializeApp } from "firebase/app"; import { getAI, getGenerativeModel, GoogleAIBackend, 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() });  // Provide an enum schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. const enumSchema = Schema.enumString({   enum: ["drama", "comedy", "documentary"], });  // Create a `GenerativeModel` instance with a model that supports your use case const model = getGenerativeModel(ai, {   model: "gemini-2.5-flash",   // In the generation config, set the `responseMimeType` to `text/x.enum`   // and pass the JSON schema object into `responseSchema`.   generationConfig: {     responseMimeType: "text/x.enum",     responseSchema: enumSchema,   }, });  let 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.`;  let result = await model.generateContent(prompt); console.log(result.response.text());  

 import 'package:firebase_ai/firebase_ai.dart'; import 'package:firebase_core/firebase_core.dart'; import 'firebase_options.dart';  // Provide an enum schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. final enumSchema = Schema.enumString(enumValues: ['drama', 'comedy', 'documentary']);  // Initialize FirebaseApp await Firebase.initializeApp(   options: DefaultFirebaseOptions.currentPlatform, );  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case final model =       FirebaseAI.googleAI().generativeModel(         model: 'gemini-2.5-flash',         // In the generation config, set the `responseMimeType` to `text/x.enum`         // and pass the enum schema object into `responseSchema`.         generationConfig: GenerationConfig(             responseMimeType: 'text/x.enum', responseSchema: enumSchema));  final 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.       """; final response = await model.generateContent([Content.text(prompt)]); print(response.text);  

 using Firebase; using Firebase.AI;  // Provide an enum schema object using a standard format. // Later, pass this schema object into `responseSchema` in the generation config. var enumSchema = Schema.Enum(new string[] { "drama", "comedy", "documentary" });  // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case var model = FirebaseAI.DefaultInstance.GetGenerativeModel(   modelName: "gemini-2.5-flash",   // In the generation config, set the `responseMimeType` to `text/x.enum`   // and pass the enum schema object into `responseSchema`.   generationConfig: new GenerationConfig(     responseMimeType: "text/x.enum",     responseSchema: enumSchema   ) );  var 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. ";  var response = await model.GenerateContentAsync(prompt); UnityEngine.Debug.Log(response.Text ?? "No text in response.");