Text mit der Gemini API generieren

Sie können ein Gemini Modell bitten, Text aus einem Prompt zu generieren, der nur Text enthält, oder einem multimodalen Prompt. Wenn Sie Firebase AI Logic verwenden, können Sie diese Anfrage direkt aus Ihrer App stellen.

Multimodale Prompts können mehrere Arten von Eingaben enthalten, z. B. Text zusammen mit Bildern, PDFs, Nur-Text-Dateien, Audio und Video.

In diesem Leitfaden wird gezeigt, wie Sie Text aus einem Prompt generieren, der nur Text enthält, und aus einem einfachen multimodalen Prompt, der eine Datei enthält.

Zum Code für Nur-Text-Eingaben springen Zum Code für multimodale Eingaben springen Zum Code für gestreamte Antworten springen


Weitere Leitfäden mit zusätzlichen Optionen für die Arbeit mit Text
Strukturierte Ausgabe generieren Wechselseitiger Chat Bidirektionales Streaming Text auf dem Gerät generieren Bilder aus Text generieren

Hinweis

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

Wenn Sie es noch nicht getan haben, folgen Sie der Anleitung für den Einstieg. Dort wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Back-End-Dienst für den ausgewählten Gemini API initialisieren und eine GenerativeModel Instanz erstellen.

Zum Testen und Iterieren Ihrer Prompts empfehlen wir Google AI Studio.

Text aus Nur-Text-Eingaben generieren

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können ein Gemini Modell bitten, Text zu generieren, indem Sie einen Prompt mit Nur-Text- Eingaben verwenden.

Swift

Sie können generateContent() aufrufen, um Text aus Nur-Text-Eingaben zu generieren.


import FirebaseAILogic

// 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-3-flash-preview")


// Provide a prompt that contains text
let prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
let response = try await model.generateContent(prompt)
print(response.text ?? "No text in response.")

Kotlin

Sie können generateContent() aufrufen, um Text aus Nur-Text-Eingaben zu generieren.

Bei Kotlin sind die Methoden in diesem SDK Suspend-Funktionen, die aus einem Coroutine-Bereich aufgerufen werden müssen. 

// 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("gemini-3-flash-preview")


// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = model.generateContent(prompt)
print(response.text)

Java

Sie können generateContent() aufrufen, um Text aus Nur-Text-Eingaben zu generieren.

Bei Java geben die Methoden in diesem SDK ein ListenableFuture zurück. 

// 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("gemini-3-flash-preview");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
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);

Web

Sie können generateContent() aufrufen, um Text aus Nur-Text-Eingaben zu generieren.


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } 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() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-3-flash-preview" });


// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call generateContent with the text input
  const result = await model.generateContent(prompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

Sie können generateContent() aufrufen, um Text aus Nur-Text-Eingaben zu generieren.


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// 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-3-flash-preview');


// Provide a prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

// To generate text output, call generateContent with the text input
final response = await model.generateContent(prompt);
print(response.text);

Einheit

Sie können GenerateContentAsync() aufrufen, um Text aus Nur-Text-Eingaben zu generieren.


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-3-flash-preview");


// Provide a prompt that contains text
var prompt = "Write a story about a magic backpack.";

// To generate text output, call GenerateContentAsync with the text input
var response = await model.GenerateContentAsync(prompt);
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Informationen zum Auswählen eines Modells , der für Ihren Anwendungsfall und Ihre App geeignet ist

Text aus Text- und Dateieingaben (multimodal) generieren

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können ein Gemini Modell bitten, Text zu generieren, indem Sie einen Prompt mit Text und einer Datei verwenden. Geben Sie dazu den `mimeType` jeder Eingabedatei mimeType und die Datei selbst an. Anforderungen und Empfehlungen für Eingabedateien finden Sie weiter unten auf dieser Seite.

Das folgende Beispiel zeigt die Grundlagen zum Generieren von Text aus einer Dateieingabe durch Analysieren einer einzelnen Videodatei, die als Inline-Daten (base64-codierte Datei) bereitgestellt wird.

In diesem Beispiel wird die Datei inline bereitgestellt. Die SDKs unterstützen aber auch die Bereitstellung einer YouTube-URL.

Swift

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text- und Videodateien zu generieren.


import FirebaseAILogic

// 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-3-flash-preview")


// Provide the video as `Data` with the appropriate MIME type.
let video = InlineDataPart(data: try Data(contentsOf: videoURL), mimeType: "video/mp4")

// Provide a text prompt to include with the video
let prompt = "What is in the video?"

// To generate text output, call generateContent with the text and video
let response = try await model.generateContent(video, prompt)
print(response.text ?? "No text in response.")

Kotlin

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text- und Videodateien zu generieren.

Bei Kotlin sind die Methoden in diesem SDK Suspend-Funktionen, die aus einem Coroutine-Bereich aufgerufen werden müssen. 

// 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("gemini-3-flash-preview")


val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    // Provide a prompt that includes the video specified above and text
    val prompt = content {
        inlineData(bytes, "video/mp4")
        text("What is in the video?")
    }

    // To generate text output, call generateContent with the prompt
    val response = model.generateContent(prompt)
    Log.d(TAG, response.text ?: "")
  }
}

Java

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text- und Videodateien zu generieren.

Bei Java geben die Methoden in diesem SDK ein ListenableFuture zurück. 

// 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("gemini-3-flash-preview");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


ContentResolver resolver = getApplicationContext().getContentResolver();
try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes the video specified above and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("What is in the video?")
                .build();

        // To generate text output, call generateContent with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        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);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Web

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text- und Videodateien zu generieren.


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } 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() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-3-flash-preview" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the video
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const videoPart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call generateContent with the text and video
  const result = await model.generateContent([prompt, videoPart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text- und Videodateien zu generieren.


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// 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-3-flash-preview');


// Provide a text prompt to include with the video
final prompt = TextPart("What's in the video?");

// Prepare video for input
final video = await File('video0.mp4').readAsBytes();

// Provide the video as `Data` with the appropriate mimetype
final videoPart = InlineDataPart('video/mp4', video);

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, ...videoPart])
]);
print(response.text);

Einheit

Sie können GenerateContentAsync() aufrufen, um Text aus multimodalen Eingaben von Text- und Videodateien zu generieren.


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-3-flash-preview");


// Provide the video as `data` with the appropriate MIME type.
var video = ModelContent.InlineData("video/mp4",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
          UnityEngine.Application.streamingAssetsPath, "yourVideo.mp4")));

// Provide a text prompt to include with the video
var prompt = ModelContent.Text("What is in the video?");

// To generate text output, call GenerateContentAsync with the text and video
var response = await model.GenerateContentAsync(new [] { video, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Informationen zum Auswählen eines Modells , der für Ihren Anwendungsfall und Ihre App geeignet ist

Antwort streamen

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können schnellere Interaktionen erzielen, indem Sie nicht auf das gesamte Ergebnis der Modellgenerierung warten, sondern Streaming verwenden, um Teilergebnisse zu verarbeiten. Rufen Sie generateContentStream auf, um die Antwort zu streamen.


Anforderungen und Empfehlungen für Eingabebilddateien

Eine als Inline-Daten bereitgestellte Datei wird bei der Übertragung in base64 codiert, wodurch die Größe der Anfrage zunimmt. Wenn eine Anfrage zu groß ist, erhalten Sie einen HTTP-Fehler 413.

Unter Unterstützte Eingabedateien und Anforderungen für die Vertex AI Gemini API finden Sie detaillierte Informationen zu folgenden Themen:

  • Verschiedene Optionen zum Bereitstellen einer Datei in einer Anfrage (entweder inline oder über die URL oder den URI der Datei)
  • Unterstützte Dateitypen
  • Unterstützte MIME-Typen und wie Sie sie angeben
  • Anforderungen und Best Practices für Dateien und multimodale Anfragen


Was können Sie sonst noch tun?

Weitere Funktionen ausprobieren

Informationen zum Steuern der Content-Generierung

Sie können auch mit Prompts und Modellkonfigurationen experimentieren und sogar ein generiertes Code-Snippet mit Google AI Studio abrufen.

Weitere Informationen zu den unterstützten Modellen

Informationen zu den für verschiedene Anwendungsfälle verfügbaren Modellen sowie zu ihren Kontingenten und Preisen.


Feedback geben zu Ihrer Erfahrung mit Firebase AI Logic