La fundamentación con
La fundamentación con
- Aumenta la precisión fáctica: 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 vivo, como el horario de atención actual y el estado en tiempo real de las estaciones de carga de 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-flash-previewgemini-3.1-flash-litegemini-2.5-progemini-2.5-flashgemini-2.5-flash-lite
Idiomas compatibles
Consulta los idiomas admitidos para los modelos Gemini.
Fundamenta el modelo con Google Maps
|
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 GoogleMaps como un 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
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 de Gemini 2.5 y versiones posteriores). Obtén más información para establecer la temperatura en la configuración del modelo.
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 los usuarios finales que los datos de
Google Maps se usan para responder sus preguntas. 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 para el SDK web) Renderiza el widget contextual
Google Maps : El widget contextual se renderiza con el token de contexto,googleMapsWidgetContextToken, que se devuelve en la respuesta Gemini API y se puede usar para renderizar contenido visual deGoogle Maps . Para obtener más información sobre el widget contextual, consulta 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 lugar que se usan para describir ubicaciones y que Grounding con
Ejemplo de propiedades de lugares
En esta lista, se proporciona una muestra alfabética de las 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 apertura
- Opciones de pago (como efectivo o tarjeta de crédito)
- Respuesta sobre un lugar
- Se permiten mascotas
- Ofrece cervezas
- Ofrece comida vegetariana
- Con acceso para personas en silla de ruedas
- Wi-Fi
Las respuestas de lugares son una respuesta de Grounding con
Ejemplos de instrucciones que usan propiedades de lugar
En los siguientes ejemplos, se usan propiedades de lugares en instrucciones sobre diferentes tipos de lugares. La fundamentación con
Planificar 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 un buen lugar para niños y ofrece comida para llevar? ¿Cuál es su calificación?
Comprobar 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.
Encuentra un lugar para comer algo a altas horas de 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 el horario de atención del viernes?
Reunirse 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: ¿"Café Central" tiene Wi-Fi? ¿Sirven café? ¿Cuál es su nivel de precios y si aceptan tarjetas de crédito?
Ten en cuenta que la información de los
Cómo funciona la fundamentación con Google Maps
Cuando le proporcionas al modelo la herramienta GoogleMaps, este se encarga de 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, al reconocer la intención geográfica, invoca la herramienta de fundamentación con
Google Maps .Envía búsquedas a
Google Maps : El servicio de fundamentación conGoogle Maps envía búsquedas aGoogle Maps para obtener información pertinente (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
Google Maps más relevantes y personalizados. La herramienta es de búsqueda textual y se comporta de manera similar a la búsqueda enGoogle Maps , ya que las búsquedas locales ("cerca de mí") usarán las coordenadas, mientras que es poco probable que las búsquedas específicas o no locales se vean influenciadas por la ubicación explícita.Procesa los resultados de
Google Maps : El modelo procesa los resultados deGoogle 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 fundamenta en los resultados deGoogle Maps . La respuesta incluye los siguientes elementos:- Es la respuesta de texto del modelo.
- Un objeto
groundingMetadatacon los resultados y las fuentes deGoogle Maps . - (Solo para el SDK web) De forma 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 Widget de fundamentación conGoogle Maps en la documentación deGoogle Maps .
Ten en cuenta que proporcionar groundingMetadata y, por lo tanto, no será un Resultado Fundamentado.
Comprende el resultado fundamentado
Si el modelo fundamenta su respuesta en los resultados de groundingMetadata que contiene datos estructurados 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 fuentes demaps(uri,placeIdytitle).groundingSupports: Es un array de fragmentos para conectar la respuesta del modelotexta las fuentes engroundingChunks. Cada fragmento vincula un textosegment(definido porstartIndexyendIndex) a uno o másgroundingChunkIndices. Este campo te ayuda a crear vínculos a la fuente intercalados. Obtén más información para cumplir con los requisitos de uso del servicio más adelante en esta página.- (Solo para el SDK web)
googleMapsWidgetContextToken: Es un token de texto que se puede usar para renderizar un widget contextual de Places. Este campo solo se devuelve cuando se usa el SDK web y si configuraste el parámetroenableWidgetcomotrue.
Este es un ejemplo de respuesta 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 de fundamentación con
Informa a los usuarios sobre las fuentes de Google Maps
Con cada groundingChunks que respaldan cada respuesta. También se devuelven los siguientes metadatos:
- URI de origen
- título
- ID
En tu app, cuando presentes resultados de la fundamentación con
Las fuentes de
Google Maps deben aparecer inmediatamente después del contenido generado que respaldan. Este contenido generado también se conoce comoGoogle Maps Resultado fundamentado.Las fuentes de
Google Maps deben poder verse en una sola interacción del usuario.
A continuación, se explica cómo obtener valores para mostrar fuentes desde el
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
}
}
}
Mostrar Google Maps fuentes con Google Maps vínculos
Para cada fuente en groundingChunks, se debe generar una vista previa del vínculo según los siguientes requisitos:
- Atribuye cada fuente a
Google Maps según los lineamientos de atribución de texto deGoogle Maps . - Muestra el título de la fuente proporcionado en la respuesta.
- Vincula la fuente con el
uride la respuesta.
Puedes contraer la vista de las fuentes.
De forma opcional, puedes mejorar la vista previa del vínculo con contenido adicional, como el siguiente:
- Un
Google Maps favicon insertado antes de la atribución de textoGoogle Maps . - Una foto de la URL de origen (
og:image).
Para obtener más información sobre algunos de los proveedores de datos de
Google Maps lineamientos para la atribución de texto
Cuando atribuyas fuentes a
No modifiques el texto
Google Mapsde ninguna manera:- No cambies las mayúsculas del texto
Google Maps. - No ajuste 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 (nº 1F1F1F) o gris (nº 5E5E5E). Mantén un contraste accesible (4.5:1) con el fondo. Tamaño de fuente Tamaño de fuente mínimo: 12 sp
Tamaño de fuente máximo: 16 sp
Para obtener más información sobre sp, consulta las unidades de tamaño de fuente en el sitio web de Material Design.Espaciado Normal
Ejemplo de CSS
El siguiente código CSS renderiza el texto Google Maps con el color y el estilo tipográfico 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 para el 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 Grounding con
Google Maps en un Territorio Prohibido. Para obtener más información, consulta Territorios prohibidos de Google Maps Platform. La lista de Territorios Prohibidos se puede actualizar periódicamente.
Resultados fundamentados y supervisión de la IA en la consola de Firebase
Si habilitaste la supervisión de la 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 de frecuencia
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