Se usó la API de Cloud Translation para traducir esta página.

Grounding with Google Search

La fundamentación con la Búsqueda de Google conecta un modelo de Gemini con contenido web público disponible en tiempo real. Esto permite que el modelo proporcione respuestas más precisas y actualizadas, y cite fuentes verificables más allá de su fecha límite de conocimiento.

La fundamentación con la Búsqueda de Google ofrece los siguientes beneficios:

Aumentar la precisión fáctica: Reduce las alucinaciones del modelo basando las respuestas en información del mundo real.
Accede a información en tiempo real: Responde preguntas sobre eventos y temas recientes.
Proporciona citas: Genera confianza en los usuarios o permíteles explorar sitios relevantes mostrando las fuentes de las afirmaciones del modelo.
Completar tareas más complejas: Recuperar artefactos e imágenes, videos o cualquier otro contenido multimedia relevantes para ayudar en las tareas de razonamiento
Mejorar las respuestas específicas para una región o un idioma: Encontrar información específica para una región o ayudar a traducir contenido con precisión

Ten en cuenta que la compatibilidad con la fundamentación para la Búsqueda de Google está disponible para iOS+, Android y la Web. Estará disponible para Flutter y Unity en sus próximas versiones.

Modelos compatibles

gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite-preview-06-17
gemini-2.0-flash-001 (y su alias actualizado automáticamente gemini-2.0-flash)
gemini-2.0-flash-live-preview-04-09

Idiomas compatibles

Consulta los idiomas admitidos para los modelos de Gemini.

Fundamenta el modelo con la Búsqueda de Google

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Cuando crees la instancia de GenerativeModel, proporciona GoogleSearch como un tool que el modelo pueda usar para generar su respuesta.

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

La compatibilidad con Flutter estará disponible en la próxima versión.

Unity

La compatibilidad con Unity estará disponible en la próxima versión.

Aprende a elegir un modelo adecuados para tu caso de uso y tu app.

Para obtener resultados ideales, usa una temperatura de 1.0 (que es la predeterminada para todos los modelos 2.5). Obtén más información para establecer la temperatura en la configuración del modelo.

Cómo funciona la fundamentación con la Búsqueda de Google

Cuando usas la herramienta GoogleSearch, el modelo controla todo el flujo de trabajo de búsqueda, procesamiento y citación de información de forma automática.

Este es el flujo de trabajo del modelo:

Recibir instrucción: Tu app envía una instrucción al modelo Gemini con la herramienta GoogleSearch habilitada.
Analizar la instrucción: El modelo analiza la instrucción y determina si la Búsqueda de Google puede mejorar su respuesta.
Envía preguntas a la Búsqueda de Google: Si es necesario, el modelo genera automáticamente una o varias preguntas de búsqueda y las ejecuta.
Procesa los resultados de la Búsqueda: El modelo procesa los resultados de la Búsqueda de Google y formula una respuesta a la instrucción original.
Devuelve un "resultado fundamentado": El modelo devuelve una respuesta final y fácil de usar que se fundamenta en los resultados de la Búsqueda de Google. Esta respuesta incluye la respuesta de texto del modelo y groundingMetadata con las búsquedas, los resultados web y las citas.

Ten en cuenta que proporcionar la Búsqueda de Google como herramienta al modelo no requiere que el modelo siempre use la herramienta de la Búsqueda de Google para generar su respuesta. En estos casos, la respuesta no contendrá un objeto groundingMetadata y, por lo tanto, no será un "resultado fundamentado".

Comprende el resultado fundamentado

Si el modelo fundamenta su respuesta en los resultados de la Búsqueda de Google, la respuesta incluye un objeto groundingMetadata que contiene datos estructurados esenciales para verificar las afirmaciones y crear una experiencia de citas enriquecida en tu aplicación.

El objeto groundingMetadata en un "resultado fundamentado" contiene la siguiente información:

webSearchQueries: Es un array de las búsquedas enviadas a la Búsqueda de Google. Esta información es útil para depurar y comprender el proceso de razonamiento del modelo.
searchEntryPoint: Contiene el código HTML y CSS para renderizar las "Sugerencias de la Búsqueda de Google" requeridas. Debes cumplir con los requisitos de uso de "Fundamentación con la Búsqueda de Google" para el proveedor de la API que elijas: Gemini Developer API o Vertex AI Gemini API (consulta la sección de Condiciones del Servicio dentro de las Condiciones Específicas del Servicio). Obtén más información para usar y mostrar un resultado fundamentado más adelante en esta página.
groundingChunks: Es un array de objetos que contiene las fuentes web (uri y title).
groundingSupports: Es un array de fragmentos para conectar la respuesta del modelo text a las fuentes en groundingChunks. Cada fragmento vincula un texto segment (definido por startIndex y endIndex) a uno o más groundingChunkIndices. Este campo te ayuda a crear citas en el texto. Más adelante en esta página, obtén información para usar y mostrar un resultado fundamentado.

Este es un ejemplo de respuesta que incluye un objeto 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]
          }
        ]
      }
    }
  ]
}

Cómo usar y mostrar un resultado fundamentado

Si el modelo usa la herramienta de Búsqueda de Google para generar una respuesta, proporcionará un objeto groundingMetadata en la respuesta.

Es obligatorio mostrar sugerencias de la Búsqueda de Google y recomendable mostrar citas.

Además de cumplir con los requisitos para usar la herramienta de la Búsqueda de Google, mostrar esta información te ayuda a ti y a tus usuarios finales a validar las respuestas y agrega vías para obtener más información.

(Obligatorio) Muestra sugerencias de la Búsqueda de Google

Si una respuesta contiene "Sugerencias de la Búsqueda de Google", debes cumplir con los requisitos de uso de "Fundamentos con la Búsqueda de Google", que incluyen la forma en que se muestran las sugerencias de la Búsqueda de Google.

El objeto groundingMetadata contiene "Sugerencias de la Búsqueda de Google", específicamente el campo searchEntryPoint, que tiene un campo renderedContent que proporciona un estilo HTML y CSS compatible, que debes implementar para mostrar sugerencias de búsqueda en tu app.

Revisa la información detallada sobre los requisitos de visualización y comportamiento de las sugerencias de la Búsqueda de Google en la documentación de Google Cloud. Ten en cuenta que, si bien esta guía detallada se encuentra en la documentación de Vertex AI Gemini API, también se aplica al proveedor de Gemini Developer API.

Consulta los ejemplos de código más adelante en esta sección.

(Recomendado) Mostrar citas

El objeto groundingMetadata contiene datos de citas estructurados, específicamente los campos groundingSupports y groundingChunks. Usa esta información para vincular las declaraciones del modelo directamente a sus fuentes dentro de tu IU (en línea y de forma agregada).

Consulta los ejemplos de código más adelante en esta sección.

Ejemplos de muestras de código

En estas muestras de código, se proporcionan patrones generalizados para usar y mostrar el resultado fundamentado. Sin embargo, es tu responsabilidad asegurarte de que tu implementación específica cumpla con los requisitos de cumplimiento.

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

La compatibilidad con Flutter estará disponible en la próxima versión.

Unity

La compatibilidad con Unity estará disponible en la próxima versión.

Resultados fundamentados y supervisión de la IA en la consola de Firebase

Si habilitaste la supervisión de IA en la consola de Firebase, las respuestas se almacenan en Cloud Logging. De forma predeterminada, estos datos tienen un período de retención de 30 días.

Es tu responsabilidad asegurarte de que este período de retención, o cualquier período personalizado que establezcas, se alinee completamente con tu caso de uso específico y con cualquier requisito de cumplimiento adicional para tu proveedor de Gemini API elegido: Gemini Developer API o Vertex AI Gemini API (consulta la sección de Condiciones del Servicio en las Condiciones Específicas del Servicio). Es posible que debas ajustar el período de retención en Cloud Logging para cumplir con estos requisitos.

Precios y límites

Asegúrate de revisar los precios, la disponibilidad del modelo y los límites para la fundamentación con la Búsqueda de Google en la documentación del proveedor de Gemini API que elijas: Gemini Developer API o Vertex AI Gemini API.