Text mit der Gemini API generieren

Sie können ein Gemini-Modell auffordern, Text aus einem Nur-Text-Prompt oder einem multimodalen Prompt zu generieren. Wenn Sie Vertex AI in Firebase verwenden, können Sie diese Anfrage direkt über Ihre App stellen.

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

In diesem Leitfaden erfahren Sie, wie Sie Text aus einem reinen Textprompt und aus einem einfachen multimodalen Prompt mit einer Datei generieren.

 Codebeispiele für die Eingabe von reinem Text  Codebeispiele für die multimodale Eingabe


Weitere Anleitungen zu Optionen für die Arbeit mit Text
Strukturierte Ausgabe generieren Chats mit mehreren Themen Bidirektionales Streaming Bilder aus Text generieren

Hinweis

Lesen Sie den Startleitfaden, in dem beschrieben wird, wie Sie ein Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Vertex AI-Dienst initialisieren und eine GenerativeModel-Instanz erstellen.

Wenn Sie Ihre Prompts testen und iterieren und sogar ein generiertes Code-Snippet erhalten möchten, empfehlen wir die Verwendung von Vertex AI Studio.

SMS senden und empfangen

Lesen Sie den Abschnitt Vorbereitung in dieser Anleitung, bevor Sie dieses Beispiel ausprobieren.

Sie können ein Gemini-Modell bitten, Text zu generieren, indem Sie es mit einer reinen Texteingabe anregen.

Swift

Sie können generateContent() aufrufen, um Text aus reiner Texteingabe zu generieren.

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-flash")

// 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 reiner Texteingabe zu generieren.

In Kotlin sind die Methoden in diesem SDK Suspend-Funktionen und müssen aus einem Coroutine-Kontext aufgerufen werden. 
// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-flash")

// 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 = generativeModel.generateContent(prompt)
print(response.text)

Java

Sie können generateContent() aufrufen, um Text aus reiner Texteingabe zu generieren.

Bei Java geben die Methoden in diesem SDK eine ListenableFuture zurück. 
// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// 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 reiner Texteingabe zu generieren.

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// 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 Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

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

// 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 reiner Texteingabe zu generieren.

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

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-flash');

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

Text und eine Datei (multimodal) senden und Text empfangen

Lesen Sie den Abschnitt Vorbereitung in dieser Anleitung, bevor Sie dieses Beispiel ausprobieren.

Sie können ein Gemini-Modell bitten, Text zu generieren, indem Sie einen Text und eine Datei als Prompt angeben. Geben Sie dazu die mimeType der jeweiligen Eingabedatei und die Datei selbst an. Anforderungen und Empfehlungen für Eingabedateien finden Sie weiter unten auf dieser Seite.

Im folgenden Beispiel wird gezeigt, wie Text aus einer Dateieingabe generiert wird, indem eine einzelne Videodatei als Inline-Daten (base64-codierte Datei) analysiert wird.

Swift

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

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-flash")

// 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 multimodaler Eingabe von Text- und Videodateien zu generieren.

In Kotlin sind die Methoden in diesem SDK Suspend-Funktionen und müssen aus einem Coroutine-Kontext aufgerufen werden. 
// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-flash")

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 = generativeModel.generateContent(prompt)
    Log.d(TAG, response.text ?: "")
  }
}

Java

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

Bei Java geben die Methoden in diesem SDK eine ListenableFuture zurück. 
// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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 multimodaler Eingabe von Text- und Videodateien zu generieren.

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// 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 Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

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

// 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 multimodaler Eingabe von Text- und Videodateien zu generieren.

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

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-flash');

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

Hier erfahren Sie, wie Sie ein Modell und optional einen Standort für Ihren Anwendungsfall und Ihre App auswählen.

Antwort streamen

Lesen Sie den Abschnitt Vorbereitung in dieser Anleitung, bevor Sie dieses Beispiel ausprobieren.

Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das vollständige Ergebnis der Modellgenerierung warten, sondern stattdessen Streaming zum Verarbeiten von Teilergebnissen verwenden. Wenn Sie die Antwort streamen möchten, rufen Sie generateContentStream auf.


Anforderungen und Empfehlungen für Eingabebilddateien

Unter Unterstützte Eingabedateien und Anforderungen an die Vertex AI Gemini API finden Sie ausführliche Informationen zu folgenden Themen:

  • Verschiedene Optionen zum Bereitstellen einer Datei in einer Anfrage (entweder inline oder mit der URL oder dem URI der Datei)
  • Unterstützte Dateitypen
  • Unterstützte MIME-Typen und deren Angabe
  • Anforderungen und Best Practices für Dateien und multimodale Anfragen


Was können Sie sonst noch tun?

Andere Funktionen ausprobieren

Inhaltserstellung steuern

Mit Vertex AI Studio können Sie auch mit Prompts und Modellkonfigurationen experimentieren.

Weitere Informationen zu den unterstützten Modellen

Hier finden Sie Informationen zu den Modellen, die für verschiedene Anwendungsfälle verfügbar sind, sowie zu ihren Kontingenten und Preisen.


Feedback zu Vertex AI in Firebase geben