使用 Gemini-API，根據多模態提示生成文字


使用 Vertex AI in Firebase SDK 從應用程式呼叫 Gemini API 時，您可以提示 Gemini 模型根據多模態輸入內容產生文字。多模態提示可包含多種模態 (或輸入類型)，例如文字和圖片、PDF、純文字檔案、影片和音訊。

在每個多模態要求中，您都必須提供下列項目：

  • 檔案為 mimeType。瞭解各個輸入檔案支援的 MIME 類型。

  • 檔案。您可以將檔案做為內嵌資料提供 (如本頁所示)，或使用檔案的網址或 URI。

如要測試及重複使用多模式提示，建議您使用 Vertex AI Studio。

事前準備

如果您尚未完成，請參閱入門指南，瞭解如何設定 Firebase 專案、將應用程式連結至 Firebase、新增 SDK、初始化 Vertex AI 服務，以及建立 GenerativeModel 例項。

從文字和單張圖片生成文字 從文字和多張圖片生成文字 從文字和影片生成文字

媒體檔案範例

如果您沒有媒體檔案，可以使用下列公開檔案。由於這些檔案儲存在不在 Firebase 專案中的儲存桶中，因此您需要使用 https://storage.googleapis.com/BUCKET_NAME/PATH/TO/FILE 格式建立網址。

使用文字和單一圖片生成文字

請先完成本指南的「事前準備」一節，再嘗試使用這個範例。

您可以使用含有文字和單一檔案 (例如圖片，如本範例所示) 的多模態提示呼叫 Gemini API。針對這些呼叫，您必須使用支援提示中媒體的模型 (例如 Gemini 2.0 Flash)。

請務必詳閱輸入檔案的規定和建議。

選擇要串流回應 (generateContentStream)，還是等待回應產生整個結果 (generateContent)。

串流 不使用串流

您可以不等待模型產生的完整結果，改用串流處理部分結果，以便加快互動速度。

以下範例說明如何使用 generateContentStream()，從包含文字和單一圖片的多模態提示要求中，串流產生的文字：

KotlinJava
對於 Kotlin，這個 SDK 中的函式為暫停函式，需要從 協同程式範圍中呼叫。
// 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")

// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To stream generated text output, call generateContentStream with the prompt
var fullResponse = ""
generativeModel.generateContentStream(prompt).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}
針對 Java，這個 SDK 中的串流方法會傳回 Reactive Streams 程式庫中的 Publisher 類型。 
// 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);

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content prompt = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To stream generated text output, call generateContentStream with the prompt
Publisher<GenerateContentResponse> streamingResponse = model.generateContentStream(prompt);

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
    }
});

或者，您可以等待整個結果，而不是串流；只有在模型完成整個產生程序後，系統才會傳回結果。

以下範例說明如何使用 generateContent()，從包含文字和單一圖片的多模態提示要求產生文字：

KotlinJava
對於 Kotlin，這個 SDK 中的函式為暫停函式，需要從 協同程式範圍中呼叫。
// 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")

// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = generativeModel.generateContent(prompt)
print(response.text)
對於 Java，這個 SDK 中的各個方法會傳回 ListenableFuture。
// 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);

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To generate text output, call generateContent with the prompt
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);

瞭解如何選擇適合用途和應用程式的模型，以及選用的位置。

使用文字和多張圖片生成文字

請先完成本指南的「事前準備」一節，再嘗試使用這個範例。

您可以使用含有文字和多個檔案 (例如圖片，如本範例所示) 的多模態提示，呼叫 Gemini API。針對這些呼叫，您必須使用支援提示中媒體的模型 (例如 Gemini 2.0 Flash)。

請務必詳閱輸入檔案的規定和建議。

選擇要串流回應 (generateContentStream)，還是等待回應產生整個結果 (generateContent)。

串流 不使用串流

您可以不等待模型產生的完整結果，改用串流處理部分結果，以便加快互動速度。

以下範例說明如何使用 generateContentStream()，從包含文字和多張圖片的多模態提示要求中，串流傳輸產生的文字：

KotlinJava
對於 Kotlin，這個 SDK 中的函式為暫停函式，需要從 協同程式範圍中呼叫。
// 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")

// Loads an image from the app/res/drawable/ directory
val bitmap1: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)
val bitmap2: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky_eats_pizza)

// Provide a prompt that includes the images specified above and text
val prompt = content {
    image(bitmap1)
    image(bitmap2)
    text("What's different between these pictures?")
}

// To stream generated text output, call generateContentStream with the prompt
var fullResponse = ""
generativeModel.generateContentStream(prompt).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}
針對 Java，這個 SDK 中的串流方法會傳回 Reactive Streams 程式庫中的 Publisher 類型。 
// 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);

Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);
Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky_eats_pizza);

// Provide a prompt that includes the images specified above and text
Content prompt = new Content.Builder()
    .addImage(bitmap1)
    .addImage(bitmap2)
    .addText("What's different between these pictures?")
    .build();

// To stream generated text output, call generateContentStream with the prompt
Publisher<GenerateContentResponse> streamingResponse = model.generateContentStream(prompt);

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
    }
});

或者，您也可以等待整個結果，而不是串流；結果只會在模型完成整個產生程序後傳回。

以下範例說明如何使用 generateContent()，從包含文字和多張圖片的多模態提示要求產生文字：

KotlinJava
對於 Kotlin，這個 SDK 中的函式為暫停函式，需要從 協同程式範圍中呼叫。
// 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")

// Loads an image from the app/res/drawable/ directory
val bitmap1: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)
val bitmap2: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky_eats_pizza)

// Provide a prompt that includes the images specified above and text
val prompt = content {
  image(bitmap1)
  image(bitmap2)
  text("What is different between these pictures?")
}

// To generate text output, call generateContent with the prompt
val response = generativeModel.generateContent(prompt)
print(response.text)
對於 Java，這個 SDK 中的各個方法會傳回 ListenableFuture。
// 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);

Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);
Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky_eats_pizza);

// Provide a prompt that includes the images specified above and text
Content prompt = new Content.Builder()
    .addImage(bitmap1)
    .addImage(bitmap2)
    .addText("What's different between these pictures?")
    .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);

瞭解如何選擇適合用途和應用程式的模型，以及選用的位置。

使用文字和影片生成文字

請先完成本指南的「事前準備」一節，再嘗試使用這個範例。

您可以使用包含文字和影片檔案的多模態提示呼叫 Gemini API (如本範例所示)。針對這些呼叫，您必須使用支援提示中媒體的模型 (例如 Gemini 2.0 Flash)。

請務必詳閱輸入檔案的規定和建議。

選擇要串流回應 (generateContentStream)，還是等待回應產生整個結果 (generateContent)。

串流 不使用串流

您可以不等待模型產生的完整結果，改用串流處理部分結果，以便加快互動速度。

以下範例說明如何使用 generateContentStream()，從包含文字和單一影片的多模態提示要求串流生成文字：

KotlinJava
對於 Kotlin，這個 SDK 中的函式為暫停函式，需要從 協同程式範圍中呼叫。
// 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 stream generated text output, call generateContentStream with the prompt
    var fullResponse = ""
    generativeModel.generateContentStream(prompt).collect { chunk ->
        Log.d(TAG, chunk.text ?: "")
        fullResponse += chunk.text
    }
  }
}
針對 Java，這個 SDK 中的串流方法會傳回 Reactive Streams 程式庫中的 Publisher 類型。 
// 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 stream generated text output, call generateContentStream with the prompt
        Publisher<GenerateContentResponse> streamingResponse =
                model.generateContentStream(prompt);

        final String[] fullResponse = {""};

        streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
            @Override
            public void onNext(GenerateContentResponse generateContentResponse) {
                String chunk = generateContentResponse.getText();
                fullResponse[0] += chunk;
            }

            @Override
            public void onComplete() {
                System.out.println(fullResponse[0]);
            }

            @Override
            public void onError(Throwable t) {
                t.printStackTrace();
            }

            @Override
            public void onSubscribe(Subscription s) {
            }
         });
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

或者，您可以等待整個結果，而不是串流；只有在模型完成整個產生程序後，系統才會傳回結果。

以下範例說明如何使用 generateContent()，從包含文字和單一影片的多模態提示要求產生文字：

KotlinJava
對於 Kotlin，這個 SDK 中的函式為暫停函式，需要從 協同程式範圍中呼叫。
// 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，這個 SDK 中的各個方法會傳回 ListenableFuture。
// 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();
}

瞭解如何選擇適合用途和應用程式的模型，以及選用的位置。

輸入檔案的規定和建議

請參閱「支援的 Vertex AI Gemini API 輸入檔案和相關規定」，瞭解下列資訊：

  • 在要求中提供檔案的不同選項
  • 支援的檔案類型
  • 支援的 MIME 類型和指定方式
  • 檔案和多模態要求的規定和最佳做法

你還可以做些什麼？

試用其他功能

瞭解如何控管內容產生

您也可以使用 Vertex AI Studio 實驗提示和模型設定。

進一步瞭解支援的型號

瞭解可用於各種用途的模型，以及相關配額和價格。


針對 Vertex AI in Firebase 的使用體驗提供意見回饋