Perujukan dengan Google Penelusuran

Grounding dengan Google Penelusuran menghubungkan model Gemini ke konten web real-time yang tersedia secara publik. Hal ini memungkinkan model memberikan jawaban yang lebih akurat dan terbaru serta mengutip sumber yang dapat diverifikasi di luar batas pengetahuan model.

Grounding dengan Google Penelusuran memiliki manfaat berikut:

• Meningkatkan akurasi faktual: Mengurangi halusinasi model dengan mendasarkan respons pada informasi dunia nyata.
• Mengakses informasi real-time: Menjawab pertanyaan tentang peristiwa dan topik terbaru.
• Memberikan kutipan: Bangun kepercayaan pengguna atau izinkan pengguna menjelajahi situs yang relevan dengan menampilkan sumber klaim model.
• Menyelesaikan tugas yang lebih kompleks: Mengambil artefak dan gambar, video, atau media lain yang relevan untuk membantu tugas penalaran.
• Meningkatkan kualitas respons khusus wilayah atau bahasa: Menemukan informasi khusus wilayah, atau membantu menerjemahkan konten secara akurat.

Perhatikan bahwa dukungan untuk Perujukan untuk Google Penelusuran tersedia untuk iOS+, Android, dan Web. Fitur ini akan tersedia untuk Flutter dan Unity dalam rilis mendatang.

Catatan untuk penayang web: Perujukan dengan Google Penelusuran tidak menggunakan halaman web untuk perujukan yang telah melarang Google-Extended. Penerbit web dapat mengelola penyertaan di Google-Extended dengan file robots.txt.

Model yang didukung

• gemini-2.5-pro
• gemini-2.5-flash
• gemini-2.5-flash-lite-preview-06-17
• gemini-2.0-flash-001 (dan aliasnya yang diupdate otomatis gemini-2.0-flash)
• gemini-2.0-flash-live-preview-04-09

Bahasa yang didukung

Lihat bahasa yang didukung untuk model Gemini.

Melakukan grounding model dengan Google Penelusuran

Klik penyedia Gemini API untuk melihat konten dan kode khusus penyedia di halaman ini. Gemini Developer API Vertex AI Gemini API

Penting: Jika respons berisi "saran Google Penelusuran" (kolom searchEntryPoint dalam objek groundingMetadata), maka respons tersebut adalah "hasil berbasis" sehingga Anda diwajibkan untuk mematuhi persyaratan penggunaan "Perujukan dengan Google Penelusuran", yang mencakup cara Anda menampilkan hasil. Pelajari cara menggunakan dan menampilkan hasil berdasar nanti di halaman ini.

Saat membuat instance GenerativeModel, berikan GoogleSearch sebagai tool yang dapat digunakan model untuk membuat responsnya.

Swift

import FirebaseAI

// 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_MODEL_NAME",
    // Provide Google Search as a tool that the model can use to generate its response
    tools: [Tool.googleSearch()]
)

let response = try await model.generateContent("Who won the euro 2024?")
print(response.text ?? "No text in response.")

// Make sure to comply with the "Grounding with Google Search" usage requirements,
// which includes how you use and display the grounded result

Kotlin

// 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_MODEL_NAME",
    // Provide Google Search as a tool that the model can use to generate its response
    tools = listOf(Tool.GoogleSearch())
)

val response = model.generateContent("Who won the euro 2024?")
print(response.text)

// Make sure to comply with the "Grounding with Google Search" usage requirements,
// which includes how you use and display the grounded result

Java

// 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_MODEL_NAME",
                        null,
                        null,
                        // Provide Google Search as a tool that the model can use to generate its response
                        List.of(Tool.GoogleSearch()));

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

ListenableFuture response = model.generateContent("Who won the euro 2024?");
  Futures.addCallback(response, new FutureCallback() {
      @Override
      public void onSuccess(GenerateContentResponse result) {
          String resultText = result.getText();
          System.out.println(resultText);
      }

      @Override
      public void onFailure(Throwable t) {
          t.printStackTrace();
      }
  }, executor);

// Make sure to comply with the "Grounding with Google Search" usage requirements,
// which includes how you use and display the grounded result

Web

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_MODEL_NAME",
    // Provide Google Search as a tool that the model can use to generate its response
    tools: [{ googleSearch: {} }]
  }
);

const result = await model.generateContent("Who won the euro 2024?");

console.log(result.response.text());

// Make sure to comply with the "Grounding with Google Search" usage requirements,
// which includes how you use and display the grounded result

Dart

Dukungan untuk Flutter akan hadir di rilis berikutnya.

Unity

Dukungan untuk Unity akan tersedia di rilis berikutnya.

Pelajari cara memilih model yang sesuai untuk kasus penggunaan dan aplikasi Anda.

Untuk hasil yang ideal, gunakan suhu 1.0 (yang merupakan setelan default untuk semua model 2.5). Pelajari cara menyetel suhu dalam konfigurasi model.

Cara kerja perujukan dengan Google Penelusuran

Saat Anda menggunakan alat GoogleSearch, model akan menangani seluruh alur kerja penelusuran, pemrosesan, dan kutipan informasi secara otomatis.

Berikut alur kerja model:

1. Menerima perintah: Aplikasi Anda mengirimkan perintah ke model Gemini dengan alat GoogleSearch diaktifkan.
2. Analisis perintah: Model menganalisis perintah dan menentukan apakah Google Penelusuran dapat meningkatkan kualitas responsnya.
3. Mengirim kueri ke Google Penelusuran: Jika diperlukan, model akan otomatis membuat satu atau beberapa kueri penelusuran dan mengeksekusinya.
4. Memproses hasil Penelusuran: Model memproses hasil Google Penelusuran dan merumuskan respons terhadap perintah asli.
5. Menampilkan "hasil yang di-grounding": Model menampilkan respons akhir yang mudah dipahami pengguna dan didasarkan pada hasil Google Penelusuran. Respons ini mencakup jawaban teks model dan groundingMetadata dengan kueri penelusuran, hasil web, dan kutipan.

Perhatikan bahwa menyediakan Google Penelusuran sebagai alat untuk model tidak mengharuskan model selalu menggunakan alat Google Penelusuran untuk membuat responsnya. Dalam kasus ini, respons tidak akan berisi objek groundingMetadata sehingga bukan "hasil yang memiliki rujukan".

Memahami hasil yang memiliki rujukan

Jika model mendasarkan responsnya pada hasil Google Penelusuran, respons tersebut akan menyertakan objek groundingMetadata yang berisi data terstruktur yang penting untuk memverifikasi klaim dan membangun pengalaman kutipan lengkap dalam aplikasi Anda.

Penting: Jika respons berisi "saran Google Penelusuran" (kolom searchEntryPoint dalam objek groundingMetadata), maka respons tersebut adalah "hasil berbasis" sehingga Anda diwajibkan untuk mematuhi persyaratan penggunaan "Perujukan dengan Google Penelusuran", yang mencakup cara Anda menampilkan hasil. Pelajari cara menggunakan dan menampilkan hasil berdasar nanti di halaman ini.

Objek groundingMetadata dalam "hasil yang memiliki rujukan" berisi informasi berikut:

• webSearchQueries: Array kueri penelusuran yang dikirim ke Google Penelusuran. Informasi ini berguna untuk men-debug dan memahami proses penalaran model.

• searchEntryPoint: Berisi HTML dan CSS untuk merender "saran Google Penelusuran" yang diperlukan. Anda diwajibkan untuk mematuhi persyaratan penggunaan "Perujukan dengan Google Penelusuran" untuk penyedia API yang Anda pilih: Gemini Developer API atau Vertex AI Gemini API (lihat bagian Persyaratan Layanan dalam Persyaratan Khusus Layanan). Pelajari cara menggunakan dan menampilkan hasil berdasar nanti di halaman ini.

• groundingChunks: Array objek yang berisi sumber web (uri dan title).

• groundingSupports: Array potongan untuk menghubungkan respons model text ke sumber dalam groundingChunks. Setiap bagian menautkan teks segment (ditentukan oleh startIndex dan endIndex) ke satu atau beberapa groundingChunkIndices. Kolom ini membantu Anda membuat kutipan inline. Pelajari cara menggunakan dan menampilkan hasil berbasis fakta nanti di halaman ini.

Berikut adalah contoh respons yang menyertakan objek groundingMetadata:

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "Spain won Euro 2024, defeating England 2-1 in the final. This victory marks Spain's record fourth European Championship title."
          }
        ],
        "role": "model"
      },
      "groundingMetadata": {
        "webSearchQueries": [
          "UEFA Euro 2024 winner",
          "who won euro 2024"
        ],
        "searchEntryPoint": {
          "renderedContent": "<!-- HTML and CSS for the search widget -->"
        },
        "groundingChunks": [
          {"web": {"uri": "https://vertexaisearch.cloud.google.com.....", "title": "aljazeera.com"}},
          {"web": {"uri": "https://vertexaisearch.cloud.google.com.....", "title": "uefa.com"}}
        ],
        "groundingSupports": [
          {
            "segment": {"startIndex": 0, "endIndex": 85, "text": "Spain won Euro 2024, defeatin..."},
            "groundingChunkIndices": [0]
          },
          {
            "segment": {"startIndex": 86, "endIndex": 210, "text": "This victory marks Spain's..."},
            "groundingChunkIndices": [0, 1]
          }
        ]
      }
    }
  ]
}

Menggunakan dan menampilkan hasil dengan perujukan

Jika model menggunakan alat Google Penelusuran untuk membuat respons, model akan memberikan objek groundingMetadata dalam respons.

Wajib untuk menampilkan saran Google Penelusuran dan direkomendasikan untuk menampilkan kutipan.

Selain mematuhi persyaratan penggunaan alat Google Penelusuran, menampilkan informasi ini akan membantu Anda dan pengguna akhir memvalidasi respons dan menambah cara untuk mempelajari lebih lanjut.

Penting: Bagian ini menjelaskan panduan dasar dan pola umum tentang cara menggunakan dan menampilkan hasil yang memiliki rujukan. Pastikan Anda meninjau dan mematuhi persyaratan penggunaan dan tampilan untuk penyedia Gemini API yang Anda pilih: Gemini Developer API atau Vertex AI Gemini API (lihat bagian Persyaratan Layanan dalam Persyaratan Khusus Layanan).

(Wajib) Menampilkan saran Google Penelusuran

Jika respons berisi "saran Google Penelusuran", Anda harus mematuhi persyaratan penggunaan "Perujukan dengan Google Penelusuran", yang mencakup cara Anda menampilkan saran Google Penelusuran.

Objek groundingMetadata berisi "saran Google Penelusuran", khususnya kolom searchEntryPoint, yang memiliki kolom renderedContent yang menyediakan gaya HTML dan CSS yang sesuai, yang harus Anda terapkan untuk menampilkan saran Penelusuran di aplikasi Anda.

Tinjau informasi mendetail tentang persyaratan tampilan dan perilaku untuk saran Google Penelusuran dalam dokumentasi Google Cloud. Perhatikan bahwa meskipun panduan mendetail ini ada dalam dokumentasi Vertex AI Gemini API, panduan ini juga berlaku untuk penyedia Gemini Developer API.

Lihat contoh kode di bagian ini.

Catatan: HTML dan CSS yang diberikan dalam respons akan otomatis menyesuaikan setelan perangkat, ditampilkan dalam mode terang atau gelap berdasarkan preferensi yang ditunjukkan oleh @media(prefers-color-scheme).

(Direkomendasikan) Menampilkan kutipan

Objek groundingMetadata berisi data kutipan terstruktur, khususnya kolom groundingSupports dan groundingChunks. Gunakan informasi ini untuk menautkan pernyataan model langsung ke sumbernya dalam UI Anda (inline dan secara gabungan).

Lihat contoh kode di bagian ini.

Contoh kode

Contoh kode ini memberikan pola umum untuk menggunakan dan menampilkan hasil yang memiliki rujukan. Namun, Anda bertanggung jawab untuk memastikan bahwa penerapan spesifik Anda sesuai dengan persyaratan kepatuhan.

Swift

// ...

// Get the model's response
let text = response.text

// Get the grounding metadata
if let candidate = response.candidates.first,
   let groundingMetadata = candidate.groundingMetadata {
  // REQUIRED - display Google Search suggestions
  // (renderedContent contains HTML and CSS for the search widget)
  if let renderedContent = groundingMetadata.searchEntryPoint?.renderedContent {
    // TODO(developer): Display Google Search suggestions using a WebView
  }

  // RECOMMENDED - display citations
  let groundingChunks = groundingMetadata.groundingChunks
  for chunk in groundingMetadata.groundingChunks {
    if let web = chunk.web {
      let title = web.title  // for example, "uefa.com"
      let uri = web.uri  // for example, "https://vertexaisearch.cloud.google.com..."
      // TODO(developer): show citation in the UI
    }
  }
}

Kotlin

// ...

// Get the model's response
val text = response.text

// Get the grounding metadata
val groundingMetadata = response.candidates.firstOrNull()?.groundingMetadata

// REQUIRED - display Google Search suggestions
// (renderedContent contains HTML and CSS for the search widget)
val renderedContent = groundingMetadata?.searchEntryPoint?.renderedContent
if (renderedContent != null) {
    // TODO(developer): Display Google Search suggestions using a WebView
}

// RECOMMENDED - display citations
val groundingChunks = groundingMetadata?.groundingChunks
groundingChunks?.let { chunks ->
  for (chunk in chunks) {
  	val title = chunk.web?.title  // for example, "uefa.com"
	val uri = chunk.web?.uri  // for example, "https://vertexaisearch.cloud.google.com..."
// TODO(developer): show citation in the UI
  }
}

Java

// ...

Futures.addCallback(response, new FutureCallback() {
  @Override
  public void onSuccess(GenerateContentResponse result) {
  // Get the model's response
  String text = result.getText();

  // Get the grounding metadata
  GroundingMetadata groundingMetadata =
  result.getCandidates()[0].getGroundingMetadata();

  if (groundingMetadata != null) {
    // REQUIRED - display Google Search suggestions
  // (renderedContent contains HTML and CSS for the search widget)
    String renderedContent =
  groundingMetadata.getSearchEntryPoint().getRenderedContent();
    if (renderedContent != null) {
      // TODO(developer): Display Google Search suggestions using a WebView
    }

    // RECOMMENDED - display citations
    List chunks = groundingMetadata.getGroundingChunks();
    if (chunks != null) {
      for(GroundingChunk chunk : chunks) {
        WebGroundingChunk web = chunk.getWeb();
        if (web != null) {
          String title = web.getTitle();  // for example, "uefa.com"
          String uri = web.getUri();  // for example, "https://vertexaisearch.cloud.google.com..."
          // TODO(developer): show citation in the UI
        }
      }
    }
  }
  }

  @Override
  public void onFailure(Throwable t) {
  t.printStackTrace();
  }
  }, executor);

Web

// ...

// Get the model's text response
const text = result.response.text();

// Get the grounding metadata
const groundingMetadata = result.response.candidates?.[0]?.groundingMetadata;

// REQUIRED - display Google Search suggestions
// (renderedContent contains HTML and CSS for the search widget)
const renderedContent = groundingMetadata?.searchEntryPoint?.renderedContent;
if (renderedContent) {
  // TODO(developer): render this HTML and CSS in the UI
}

// RECOMMENDED - display citations
const groundingChunks = groundingMetadata?.groundingChunks;
if (groundingChunks) {
  for (const chunk of groundingChunks) {
    const title = chunk.web?.title;  // for example, "uefa.com"
    const uri = chunk.web?.uri;  // for example, "https://vertexaisearch.cloud.google.com..."
    // TODO(developer): show citation in the UI
  }
}

Dart

Dukungan untuk Flutter akan hadir di rilis berikutnya.

Unity

Dukungan untuk Unity akan tersedia di rilis berikutnya.

Hasil berbasis dan pemantauan AI di Firebase console

Jika Anda telah mengaktifkan pemantauan AI di Firebase console, respons akan disimpan di Cloud Logging. Secara default, data ini memiliki periode retensi 30 hari.

Anda bertanggung jawab untuk memastikan bahwa periode retensi ini, atau periode kustom yang Anda tetapkan, sepenuhnya selaras dengan kasus penggunaan spesifik Anda dan persyaratan kepatuhan tambahan untuk penyedia Gemini API yang Anda pilih: Gemini Developer API atau Vertex AI Gemini API (lihat bagian Persyaratan Layanan dalam Persyaratan Khusus Layanan). Anda mungkin perlu menyesuaikan periode retensi di Cloud Logging untuk memenuhi persyaratan ini.

Harga dan batas

Pastikan untuk meninjau harga, ketersediaan model, dan batas untuk perujukan dengan Penelusuran Google dalam dokumentasi penyedia Gemini API yang Anda pilih: Gemini Developer API | Vertex AI Gemini API.