La fundamentación con
La fundamentación con
- Aumenta la precisión factual: Reduce las alucinaciones del modelo basando las respuestas en la base de datos de Google de más de 250 millones de lugares y empresas del mundo real.
- Accede a información en tiempo real: Responde preguntas con datos en tiempo real, como el horario de atención actual y el estado en tiempo real de las estaciones de carga para VE.
- Proporciona contexto visual: Genera confianza en los usuarios integrando widgets de mapas interactivos, fotos y Street View directamente junto con las afirmaciones basadas en la ubicación del modelo.
Modelos compatibles
gemini-3.1-pro-previewgemini-3.5-flashgemini-3.1-flash-litegemini-2.5-progemini-2.5-flashgemini-2.5-flash-lite
Idiomas compatibles
Consulta los idiomas compatibles con los modelos Gemini.
Fundamenta el modelo con Google Maps
|
Haz clic en tu proveedor de Gemini API para ver el contenido específico del proveedor y el código en esta página. |
Cuando crees la instancia GenerativeModel, proporciona GoogleMaps como una tool que el modelo pueda usar para generar su respuesta.
Swift
import FirebaseAILogic
// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Example: Coordinates for New York City
let latAndLong = CLLocationCoordinate2D(latitude: 40.7128, longitude: -74.0060)
// (Optional) Define a RetrievalConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
let retrievalConfig = RetrievalConfig(
location: latAndLong,
// Example: Language code for English (US).
languageCode: "en_US"
)
// Wrap the RetrievalConfig inside a ToolConfig.
let toolConfig = ToolConfig(retrievalConfig: retrievalConfig)
// Create a `GenerativeModel` instance with a model that supports your use case.
let model = ai.generativeModel(
modelName: "GEMINI_MODEL_NAME",
// Provide Google Maps as a tool that the model can use to generate its response.
tools: [Tool.googleMaps()],
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig: toolConfig
)
let response = try await model.generateContent("restaurants near me?")
print(response.text ?? "No text in response.")
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Kotlin
// (Optional) Define a RetrievalConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
val retrievalConfig = RetrievalConfig(
// Example: Coordinates for New York City
latLng = LatLng(latitude = 40.7128, longitude = -74.0060),
// Example: Language code for English (US)
languageCode = "en_US"
)
// Wrap the RetrievalConfig inside a ToolConfig.
val toolConfig = ToolConfig(
retrievalConfig = retrievalConfig
)
// 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",
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig = toolConfig,
// Provide Google Maps as a tool that the model can use to generate its response.
tools = listOf(Tool.googleMaps())
)
val response = model.generateContent("restaurants near me?")
print(response.text)
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Java
// (Optional) Define a ToolConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
ToolConfig toolConfig = new ToolConfig(
null,
new RetrievalConfig(
// Example: Coordinates for New York City.
new LatLng(40.7128, -74.0060),
// Example: Language code for English (US).
"en_US"
)
);
// 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 Maps as a tool that the model can use to generate its response.
List.of(Tool.googleMaps()),
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig);
// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
ListenableFuture response = model.generateContent("restaurants near me?");
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 Maps " usage requirements,
// which includes how you meet service usage requirements
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() });
// (Optional) Define a toolConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
const toolConfig = {
retrievalConfig: {
// Example: Coordinates for New York City
latLng: {
latitude: 40.7128,
longitude: -74.0060
},
// Example: Language code for English (US)
languageCode: 'en-US'
}
};
// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(
ai,
{
model: "GEMINI_MODEL_NAME",
// Provide Google Maps as a tool that the model can use to generate its response.
// (Optional) Set `enableWidget` to control whether the response contains a `googleMapsWidgetContextToken`.
tools: [ { googleMaps: { enableWidget: true } } ],
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig
}
);
const result = await model.generateContent("restaurants near me?");
console.log(result.response.text());
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Dart
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_ai/firebase_ai.dart';
import 'firebase_options.dart';
// Initialize FirebaseApp.
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
// (Optional) Define a ToolConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
final toolConfig = ToolConfig(
retrievalConfig: RetrievalConfig(
// Example: Coordinates for New York City.
latLng: LatLng(latitude: 40.712728, longitude: -74.006015),
// Example: Language code for English (US).
languageCode: 'en',
),
);
// 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_MODEL_NAME',
// Provide Google Maps as a tool that the model can use to generate its response.
tools: [
Tool.googleMaps(),
],
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig: toolConfig,
);
final response = await model.generateContent([Content.text("restaurants near me?")]);
print(response.text);
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Unity
using Firebase;
using Firebase.AI;
// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
// Example: Coordinates for New York City
var latLng = new LatLng(40.7128, -74.0060);
// (Optional) Define a RetrievalConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
var retrievalConfig = new RetrievalConfig(latLng, languageCode: "en");
// Wrap the RetrievalConfig inside a ToolConfig.
var toolConfig = new ToolConfig(retrievalConfig: retrievalConfig);
// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(
modelName: "GEMINI_MODEL_NAME",
// Provide Google Maps as a tool that the model can use to generate its response.
tools: new[] { new Tool(new GoogleMaps()) },
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig: toolConfig
);
var response = await model.GenerateContentAsync("restaurants near me?");
UnityEngine.Debug.Log(response.Text ?? "No text in response.");
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Obtén información para elegir un modelo adecuada para tu caso de uso y tu app.
Prácticas recomendadas y sugerencias para mejorar los resultados
En esta sección, se describen algunas prácticas recomendadas generales para usar la fundamentación con
Prácticas recomendadas generales
Proporciona la herramienta solo cuando sea necesario: Para optimizar el rendimiento y el costo, proporciona al modelo acceso a la herramienta de fundamentación con
Google Maps solo cuando el caso de uso tenga un contexto geográfico claro.Proporciona la ubicación del usuario: Para obtener las respuestas más relevantes y personalizadas (y cuando se conoce la ubicación del usuario), incluye la ubicación del usuario (con latitud y longitud a través de
latLng) en la configuración de la herramienta de fundamentación conGoogle Maps .Informa a los usuarios finales: Informa claramente a tus usuarios finales que se usan datos de
Google Maps para responder sus consultas. Proporcionar a los usuarios finales las fuentes deGoogle Maps es un requisito de uso del servicio para la herramienta de fundamentación conGoogle Maps .(Solo SDK web) Renderiza el widget contextual de
Google Maps : El widget contextual se renderiza con el token de contexto,googleMapsWidgetContextToken, que se muestra en la respuesta de la Gemini API y se puede usar para renderizar contenido visual deGoogle Maps . Para obtener más información sobre el widget contextual, consulta el widget de fundamentación conGoogle Maps en la documentación deGoogle Maps .
Usa propiedades de lugares en las instrucciones
En esta sección, se enumeran las propiedades de lugares que se usan para describir ubicaciones
y que la fundamentación con
Propiedades de lugares de muestra
En esta lista, se proporciona una muestra alfabética de propiedades sobre lugares que tu modelo puede usar para generar respuestas.
- Dirección
- Retiros en la puerta
- Tarjeta de débito
- Distancia
- Estacionamiento gratuito
- Música en vivo
- Menú para niños
- Horario de atención
- Opciones de pago (como efectivo o tarjeta de crédito)
- Respuesta sobre lugares
- Se permiten mascotas
- Ofrece cervezas
- Tiene comida vegetariana
- Con acceso para personas en silla de ruedas
- Wi-Fi
Las respuestas sobre lugares son una respuesta de la fundamentación con
Ejemplos de instrucciones que usan propiedades de lugares
En los siguientes ejemplos, se usan
propiedades de lugares
en instrucciones sobre diferentes tipos de lugares. La fundamentación con
Planifica una cena familiar: Determina si un restaurante es adecuado para una familia y si ofrece un servicio conveniente.
- Ejemplo de instrucción: ¿"The Italian Place" es bueno para los niños y ofrece comida para llevar? ¿Cuál es su calificación?
Verifica la accesibilidad para un amigo: Determina si la ubicación satisface necesidades de accesibilidad específicas.
- Ejemplo de instrucción: Necesito un restaurante que tenga una entrada accesible para sillas de ruedas.
Busca un lugar para comer algo tarde por la noche: Busca un establecimiento abierto que sirva una comida específica durante un horario determinado.
- Ejemplo de instrucción: ¿"Burger Joint" está abierto ahora? ¿Sirven cena? ¿Cuál es su horario de atención para el viernes?
Reúnete con un cliente para tomar un café: Evalúa la idoneidad de una cafetería para una reunión de negocios en función de las comodidades, las ofertas y las opciones de pago.
- Ejemplo de instrucción: ¿"Cafe Central" tiene Wi-Fi? ¿Sirven café? ¿Cuál es su nivel de precios y aceptan tarjetas de crédito?
Ten en cuenta que la información de los
Cómo funciona la fundamentación con Google Maps
Cuando proporcionas la herramienta GoogleMaps al modelo, este 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:
Recibe la instrucción: Tu app envía una instrucción al modelo de Gemini con la herramienta
GoogleMapshabilitada.Analiza la instrucción: El modelo analiza la instrucción y determina si
Google Maps puede mejorar su respuesta, por ejemplo, si la instrucción contiene contexto geográfico (como "cafeterías cerca de mí" o "museos en San Francisco").Invoca la herramienta: El modelo, que reconoce la intención geográfica, invoca la herramienta de fundamentación con
Google Maps .Envía consultas a
Google Maps : El servicio de fundamentación conGoogle Maps consulta aGoogle Maps para obtener información relevante (por ejemplo, lugares, opiniones, fotos, direcciones y horarios de atención).De manera opcional, puedes incluir la latitud y la longitud en la configuración de la herramienta (o incluso directamente en la instrucción) para obtener resultados más relevantes y personalizados
Google Maps . La herramienta es una herramienta de búsqueda textual y se comporta de manera similar a la búsqueda enGoogle Maps , ya que las consultas locales ("cerca de mí") usarán las coordenadas, mientras que es poco probable que las consultas específicas o no locales se vean influenciadas por la ubicación explícita.Procesa los resultados
Google Maps : El modelo procesa los resultadosGoogle Maps y formula una respuesta a la instrucción original.Devuelve un
Google Maps resultado fundamentado: El modelo devuelve una respuesta final y fácil de usar que se basa en losGoogle Maps resultados. La respuesta incluye los siguientes elementos:- La respuesta de texto del modelo
- Un objeto
groundingMetadatacon los resultados y las fuentes.Google Maps - (Solo SDK web) De manera opcional, un googleMapsWidgetContextToken que te permite
renderizar un widget contextual
Google Maps en tu app para la interacción visual Para obtener más información sobre el widget contextual, consulta el widget de fundamentación conGoogle Maps en la documentación.Google Maps
Ten en cuenta que proporcionar groundingMetadata y, por lo tanto,
no es un resultado fundamentado de
Comprende el resultado fundamentado
Si el modelo fundamenta su respuesta en los resultados de groundingMetadata que contiene datos estructurados que son
esenciales para verificar las afirmaciones y crear una experiencia de fuente enriquecida en tu
aplicación.
El objeto groundingMetadata en un
groundingChunks: Es un array de objetos que contiene las fuentesmaps(uri,placeIdytitle).groundingSupports: Es un array de fragmentos para conectar la respuesta del modelotexta las fuentes engroundingChunks. Cada fragmento vincula unsegmentde texto (definido porstartIndexyendIndex) a uno o másgroundingChunkIndices. Este campo te ayuda a crear vínculos de origen intercalados. Obtén información para cumplir con los requisitos de uso del servicio más adelante en esta página.- (Solo SDK web)
googleMapsWidgetContextToken: Es un token de texto que se puede usar para renderizar un widget contextual de Places. Este campo solo se muestra cuando se usa el SDK web y si estableciste el parámetroenableWidgetentrue.
Esta es una respuesta de ejemplo que incluye un objeto groundingMetadata:
{
"candidates": [
{
"content": {
"parts": [
{
"text": "CanteenM is an American restaurant with..."
}
],
"role": "model"
},
"groundingMetadata": {
"groundingChunks": [
{
"maps": {
"uri": "https://maps.google.com/?cid=13100894621228039586",
"title": "Heaven on 7th Marketplace",
"placeId": "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
}
}
],
"groundingSupports": [
{
"segment": {
"startIndex": 0,
"endIndex": 79,
"text": "CanteenM is an American restaurant with a 4.6-star rating and is open 24 hours."
},
"groundingChunkIndices": [0]
}
],
"googleMapsWidgetContextToken": "widgetcontent/..."
}
}
]
}
Requisitos de uso del servicio
En esta sección, se describen los requisitos de uso del servicio para la fundamentación con
Informa a los usuarios sobre las fuentes de Google Maps
Con cada groundingChunks que admiten cada respuesta. También se muestran los siguientes metadatos:
- URI de origen
- título
- ID
En tu app, cuando presentes resultados de la fundamentación con
Las fuentes
Google Maps deben aparecer inmediatamente después del contenido generado que admiten las fuentes. Este contenido generado también se conoce comoGoogle Maps resultado fundamentado.Las fuentes de
Google Maps deben poder verse en una interacción del usuario.
A continuación, se explica cómo obtener valores para mostrar fuentes del
Swift
// ...
// Get the model's response
let text = response.text
// Get the grounding metadata
if let candidate = response.candidates.first,
let groundingMetadata = candidate.groundingMetadata {
// Get sources
let groundingChunks = groundingMetadata.groundingChunks
for chunk in groundingChunks {
if let maps = chunk.maps {
let title = maps.title // for example, "Heaven on 7th Marketplace"
let url = maps.url // for example, "https://maps.google.com/?cid=13100894621228039586"
let placeId = maps.placeId // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show source in the UI
}
}
}
Kotlin
// ...
// Get the model's response
val text = response.text
// Get the grounding metadata
val groundingMetadata = response.candidates.firstOrNull()?.groundingMetadata
// Get sources
val groundingChunks = groundingMetadata?.groundingChunks
groundingChunks?.let { chunks ->
for (chunk in chunks) {
val title = chunk.maps?.title // for example, "Heaven on 7th Marketplace"
val uri = chunk.maps?.uri // for example, "https://maps.google.com/?cid=13100894621228039586"
val placeId = chunk.maps?.placeId // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show source 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) {
// Get sources
List chunks = groundingMetadata.getGroundingChunks();
if (chunks != null) {
for(GroundingChunk chunk : chunks) {
GoogleMapsGroundingChunk maps = chunk.getMaps();
if (maps != null) {
String title = maps.getTitle(); // for example, "Heaven on 7th Marketplace"
String uri = maps.getUri(); // for example, "https://maps.google.com/?cid=13100894621228039586"
String placeId = maps.getPlaceId(); // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources 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;
// Get sources
const groundingChunks = groundingMetadata?.groundingChunks;
if (groundingChunks) {
for (const chunk of groundingChunks) {
const title = chunk.maps?.title; // for example, "Heaven on 7th Marketplace"
const uri = chunk.maps?.uri; // for example, "https://maps.google.com/?cid=13100894621228039586"
const placeId = chunk.maps?.placeId; // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
Dart
// ...
// Get the model's response
final text = response.text;
// Get the grounding metadata
final groundingMetadata = response.candidates.first.groundingMetadata;
// Get sources
final groundingChunks = groundingMetadata?.groundingChunks;
if (groundingChunks != null) {
for (var chunk in groundingChunks) {
final title = chunk.maps?.title; // for example, "Heaven on 7th Marketplace"
final uri = chunk.maps?.uri; // for example, "https://maps.google.com/?cid=13100894621228039586"
final placeId = chunk.maps?.placeId; // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
Unity
// ...
// Get the model's response
var text = response.Text;
// Get the grounding metadata
var groundingMetadata = response.Candidates.First().GroundingMetadata;
// Get sources
if (groundingMetadata != null) {
foreach(GroundingChunk chunk in groundingMetadata?.GroundingChunks) {
if (chunk.Maps != null) {
var title = chunk.Maps?.Title; // for example, "Heaven on 7th Marketplace"
var uri = chunk.Maps?.Uri; // for example, "https://maps.google.com/?cid=13100894621228039586"
var placeId = chunk.Maps?.PlaceId; // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
}
Muestra fuentes de Google Maps con vínculos de Google Maps
Para cada fuente en groundingChunks, se debe generar una vista previa del vínculo que cumpla con los siguientes requisitos:
- Atribuye cada fuente a
Google Maps según losGoogle Maps lineamientos de atribución de texto. - Muestra el título de la fuente que se proporciona en la respuesta.
- Vincula a la fuente con la
uride la respuesta.
Puedes contraer la vista de las fuentes.
De manera opcional, puedes mejorar la vista previa del vínculo con contenido adicional, como el siguiente:
- Un
Google Maps favicon insertado antes de laGoogle Maps atribución de texto. - Una foto de la URL de origen (
og:image)
Para obtener más información sobre algunos de los
Lineamientos de atribución de textoGoogle Maps
Cuando atribuyas fuentes a
No modifiques el texto
Google Mapsde ninguna manera:- No cambies las mayúsculas del texto
Google Maps. - No ajustes el texto
Google Mapsen varias líneas. - No localices el texto
Google Mapsen otro idioma. - Evita que los navegadores traduzcan el texto
Google Mapsusando el atributo HTMLtranslate="no".
- No cambies las mayúsculas del texto
Aplica el estilo al texto
Google Mapscomo se describe en la siguiente tabla:Propiedad Estilo Familia de fuentes Roboto. La carga de la fuente es opcional. Familia de fuentes de resguardo Cualquier fuente de cuerpo Sans Serif que ya se use en tu producto o "Sans-Serif" para invocar la fuente predeterminada del sistema Estilo de fuente Normal Grosor de la fuente 400 Color de la fuente Blanco, negro (#1F1F1F) o gris (#5E5E5E). Mantén un contraste accesible (4.5:1) con el fondo. Tamaño de fuente Tamaño de fuente mínimo: 12sp
Tamaño de fuente máximo: 16sp
Para obtener información sobre sp, consulta Unidades de tamaño de fuente en el sitio web de Material Design.Espaciado Normal
Ejemplo de CSS
El siguiente CSS renderiza el texto Google Maps con el estilo tipográfico y el color adecuados sobre un fondo blanco o claro.
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
.GMP-attribution {
font-family: Roboto, Sans-Serif;
font-style: normal;
font-weight: 400;
font-size: 1rem;
letter-spacing: normal;
white-space: nowrap;
color: #5e5e5e;
}
Almacenamiento en caché del token de contexto y el ID de lugar
El
- (Solo SDK web)
googleMapsWidgetContextToken placeId
Las restricciones contra el almacenamiento en caché en las Condiciones de la fundamentación con Google Maps no se aplican a estos datos.
Actividades y territorios prohibidos
La fundamentación con
No usarás la fundamentación con
Google Maps para actividades de alto riesgo incluidos los servicios de respuesta ante emergencias.No distribuirás ni comercializarás tu aplicación que ofrece la fundamentación con
Google Maps en un territorio prohibido. Para obtener más información, consulta Territorios prohibidos de Google Maps Platform. Es posible que la lista de territorios prohibidos se actualice ocasionalmente.
Resultados fundamentados y supervisión de la IA en la Firebase consola
Si habilitaste la supervisión de la IA en la Firebase consola, 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 por completo con tu caso de uso específico y con cualquier requisito de cumplimiento adicional para el proveedor que elegiste: o (consulta la sección Condiciones del servicio en las Condiciones específicas del servicio).Gemini APIGemini Developer APIVertex AI Gemini API Es posible que debas ajustar el período de retención en Cloud Logging para cumplir con estos requisitos.
Precios y límites de frecuencia
Los precios de la fundamentación con
Asegúrate de revisar los detalles sobre los precios, la disponibilidad del modelo y los límites de la
fundamentación con