Il grounding con
La messa a terra con
- Aumenta l'accuratezza dei fatti: riduci le allucinazioni del modello basando le risposte sul database di Google di oltre 250 milioni di luoghi e attività reali.
- Accedere a informazioni in tempo reale: rispondi alle domande utilizzando dati in tempo reale, ad esempio l'orario di apertura attuale e lo stato in tempo reale delle stazioni di ricarica EV.
- Fornisci un contesto visivo: crea fiducia negli utenti integrando widget di mappe interattive, foto e Street View direttamente accanto alle affermazioni basate sulla posizione del modello.
Modelli supportati
gemini-3.1-pro-previewgemini-3.5-flashgemini-3.1-flash-litegemini-2.5-progemini-2.5-flashgemini-2.5-flash-lite
Lingue supportate
Consulta le lingue supportate per i modelli Gemini.
Fondare il modello con Google Maps
|
Fai clic sul tuo fornitore Gemini API per visualizzare i contenuti e il codice specifici del fornitore in questa pagina. |
Quando crei l'istanza GenerativeModel, fornisci GoogleMaps come tool
che il modello può utilizzare per generare la risposta.
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
Scopri come scegliere un modello adatta al tuo caso d'uso e alla tua app.
Best practice e suggerimenti per migliorare i risultati
Questa sezione descrive alcune best practice generali per l'utilizzo di Grounding con
Best practice generali
Fornisci lo strumento solo quando necessario: per ottimizzare il rendimento e i costi, fornisci al modello l'accesso allo strumento Grounding con
Google Maps solo quando il caso d'uso ha un contesto geografico chiaro.Fornisci la posizione dell'utente: per le risposte più pertinenti e personalizzate (e quando la posizione dell'utente è nota), includi la posizione dell'utente (utilizzando latitudine e longitudine tramite
latLng) nella configurazione dello strumento Grounding conGoogle Maps .Informa gli utenti finali: informa chiaramente gli utenti finali che i dati di
Google Maps vengono utilizzati per rispondere alle loro query. Fornire agli utenti finali le fonti diGoogle Maps è un requisito di utilizzo del servizio per lo strumento Grounding conGoogle Maps .(Solo SDK web) Visualizza il
Google Maps widget contestuale: il widget contestuale viene visualizzato utilizzando il token contestuale,googleMapsWidgetContextToken, restituito nella risposta Gemini API e può essere utilizzato per visualizzare contenuti visivi daGoogle Maps . Per ulteriori informazioni sul widget contestuale, consulta Widget di grounding conGoogle Maps nella documentazione diGoogle Maps .
Utilizzare le proprietà dei luoghi nei prompt
Questa sezione elenca le proprietà dei luoghi utilizzate per descrivere le località
e utilizzate da Grounding con
Proprietà del luogo di esempio
Questo elenco fornisce un campionamento in ordine alfabetico delle proprietà dei luoghi che possono essere utilizzate dal modello per generare risposte.
- Indirizzo
- Ritiro all'esterno
- Carta di debito
- Distanza
- Parcheggio gratuito
- Musica dal vivo
- Menu per bambini
- Orario di apertura
- Opzioni di pagamento (ad es. contanti o carta di credito)
- Risposta sul luogo
- Animali ammessi
- Serve birra
- Serve cibo vegetariano
- Accessibile in sedia a rotelle
- Wi-Fi
Le risposte sui luoghi sono una risposta di Grounding con
Prompt di esempio che utilizzano le proprietà del luogo
Gli esempi seguenti utilizzano
le proprietà dei luoghi
nei prompt relativi a diversi tipi di luoghi. Il grounding con
Organizzare una cena in famiglia: determina se un ristorante è adatto a una famiglia e se offre un servizio comodo.
- Prompt di esempio: "The Italian Place" è un buon ristorante per i bambini e offre il servizio d'asporto? Qual è la loro valutazione?
Controllare l'accessibilità per un amico: determina se la posizione soddisfa esigenze di accessibilità specifiche.
- Prompt di esempio: Ho bisogno di un ristorante con un ingresso accessibile in sedia a rotelle.
Trovare un luogo per uno spuntino a tarda notte: trova un'attività aperta che serve un pasto specifico in un determinato orario.
- Prompt di esempio: "Burger Joint" è aperto ora? Serve la cena? Quali sono gli orari di apertura per venerdì?
Incontrare un cliente per un caffè: valuta l'idoneità di un bar per un incontro di lavoro in base ai servizi, alle offerte e alle opzioni di pagamento.
- Prompt di esempio: Il "Cafe Central" ha il Wi-Fi? Servono caffè? Qual è il loro livello di prezzo e accettano carte di credito?
Tieni presente che le informazioni nei
Come funziona Grounding con Google Maps
Quando fornisci al modello lo strumento GoogleMaps, il modello gestisce
automaticamente l'intero flusso di lavoro di ricerca, elaborazione e citazione delle informazioni.
Ecco il flusso di lavoro del modello:
Riceve il prompt: la tua app invia un prompt al modello Gemini con lo strumento
GoogleMapsattivato.Analizza il prompt: il modello analizza il prompt e determina se
Google Maps può migliorare la sua risposta, ad esempio se il prompt contiene un contesto geografico (come "caffetterie vicino a me", "musei a San Francisco").Richiama lo strumento: il modello, riconoscendo l'intento geografico, richiama lo strumento Grounding con
Google Maps .Invia query a
Google Maps : il servizio Grounding conGoogle Maps interrogaGoogle Maps per ottenere informazioni pertinenti (ad esempio, luoghi, recensioni, foto, indirizzi, orari di apertura).Se vuoi ottenere risultati più pertinenti e personalizzati, puoi includere facoltativamente la latitudine e la longitudine nella configurazione dello strumento (o anche solo nel prompt).
Google Maps Lo strumento è uno strumento di ricerca testuale e si comporta in modo simile alla ricerca suGoogle Maps , in quanto le query locali ("vicino a me") utilizzeranno le coordinate, mentre è improbabile che le query specifiche o non locali siano influenzate dalla posizione esplicita.Elabora i
Google Maps risultati: il modello elabora iGoogle Maps risultati e formula una risposta al prompt originale.Restituisce un
Google Maps Risultato fondato: il modello restituisce una risposta finale e facile da usare basata sui risultati diGoogle Maps . Questa risposta include:- La risposta di testo del modello.
- Un oggetto
groundingMetadatacon i risultati e le fontiGoogle Maps . - (Solo SDK per il web) Facoltativamente, un googleMapsWidgetContextToken che ti consente di
visualizzare un widget
Google Maps contestuale nella tua app per l'interazione visiva. Per saperne di più sul widget contestuale, consulta Grounding con il widgetGoogle Maps nella documentazione diGoogle Maps .
Tieni presente che fornire groundingMetadata e quindi
non è un
Comprendere il risultato basato su dati reali
Se il modello basa la sua risposta sui risultati di groundingMetadata che contiene dati strutturati essenziali
per verificare le affermazioni e creare un'esperienza di fonti avanzata nella tua
applicazione.
L'oggetto groundingMetadata in un
groundingChunks: un array di oggetti contenenti le originimaps(uri,placeIdetitle).groundingSupports: un array di blocchi per collegare la risposta del modellotextalle fonti ingroundingChunks. Ogni blocco collega un testosegment(definito dastartIndexeendIndex) a uno o piùgroundingChunkIndices. Questo campo ti aiuta a creare link alle fonti in linea. Scopri come soddisfare i requisiti di utilizzo del servizio più avanti in questa pagina.- (Solo SDK web)
googleMapsWidgetContextToken: un token di testo che può essere utilizzato per il rendering di un widget Places contestuale. Questo campo viene restituito solo quando utilizzi l'SDK web e se hai impostato il parametroenableWidgetsutrue.
Ecco un esempio di risposta che include un oggetto 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/..."
}
}
]
}
Requisiti per l'utilizzo del servizio
Questa sezione descrive i requisiti di utilizzo del servizio per Grounding con
Informare gli utenti delle origini Google Maps
Per ogni groundingChunks che supportano ogni risposta. Vengono restituiti anche i seguenti metadati:
- source uri
- titolo
- ID
Nella tua app, quando presenti i risultati di Grounding con
Le fonti
Google Maps devono seguire immediatamente i contenuti generati che supportano. Questi contenuti generati sono anche chiamatiGoogle Maps Risultato basato su dati reali.Le origini
Google Maps devono essere visualizzabili con una sola interazione dell'utente.
Ecco come ottenere i valori per la visualizzazione delle fonti dal
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
}
}
}
Mostra Google Maps fonti con Google Maps link
Per ogni origine in groundingChunks,
deve essere generata un'anteprima del link in base ai seguenti requisiti:
- Attribuisci ogni fonte a
Google Maps seguendo leGoogle Maps linee guida per l'attribuzione del testo. - Mostra il titolo della fonte fornito nella risposta.
- Collega la fonte utilizzando
uridalla risposta.
Puoi comprimere la visualizzazione delle fonti.
Se vuoi, puoi migliorare l'anteprima del link con contenuti aggiuntivi, ad esempio:
- Una
Google Maps favicon inserita prima dell'attribuzione del testoGoogle Maps . - Una foto dall'URL di origine (
og:image).
Per ulteriori informazioni su alcuni dei fornitori di dati
Google Maps linee guida per l'attribuzione del testo
Quando attribuisci le fonti a
Non modificare in alcun modo il testo
Google Maps:- Non modificare le maiuscole del testo
Google Maps. - Non mandare a capo il testo
Google Mapssu più righe. - Non localizzare il testo
Google Mapsin un'altra lingua. - Impedisci ai browser di tradurre il testo
Google Mapsutilizzando l'attributo HTMLtranslate="no".
- Non modificare le maiuscole del testo
Formatta il testo
Google Mapscome descritto nella tabella seguente:Proprietà Stile Famiglia di caratteri Roboto. Il caricamento del carattere è facoltativo. Famiglia di caratteri di riserva Qualsiasi carattere del corpo sans-serif già utilizzato nel tuo prodotto o "Sans-Serif" per richiamare il carattere di sistema predefinito Stile carattere Normale Spessore del carattere 400 Colore carattere Bianco, nero (#1F1F1F) o grigio (#5E5E5E). Mantenere un contrasto accessibile (4,5:1) rispetto allo sfondo. Dimensione carattere Dimensione minima del carattere: 12 sp
Dimensione massima del carattere: 16 sp
Per saperne di più su sp, consulta Unità di misura delle dimensioni del carattere sul sito web Material Design.Spaziatura Normale
CSS di esempio
Il seguente CSS esegue il rendering del testo Google Maps con lo stile tipografico e il colore appropriati su uno sfondo bianco o chiaro.
@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;
}
Memorizzazione nella cache del token di contesto e dell'ID luogo
Il
- (Solo SDK web)
googleMapsWidgetContextToken placeId
Le limitazioni alla memorizzazione nella cache previste dai Termini del Grounding con Google Maps non si applicano a questi dati.
Attività e territori vietati
La base con
Non utilizzerai la funzionalità di fondatezza con
Google Maps per attività ad alto rischio, inclusi i servizi di risposta alle emergenze.Non distribuirai né commercializzerai la tua applicazione che offre Grounding con
Google Maps in un Territorio vietato. Per ulteriori informazioni, consulta la pagina Territori vietati di Google Maps Platform. L'elenco dei Territori vietati potrebbe essere aggiornato di tanto in tanto.
Risultati basati su dati reali e monitoraggio dell'AI nella console Firebase
Se hai attivato il monitoraggio AI nella console Firebase, le risposte vengono archiviate in Cloud Logging. Per impostazione predefinita, questi dati hanno un periodo di conservazione di 30 giorni.
È tua responsabilità assicurarti che questo periodo di conservazione o qualsiasi periodo personalizzato che imposti sia pienamente in linea con il tuo caso d'uso specifico e con eventuali requisiti di conformità aggiuntivi per il tuo fornitore Gemini API scelto: Gemini Developer API o Vertex AI Gemini API (vedi la sezione Termini di servizio all'interno dei Termini specifici del servizio). Potresti dover modificare il periodo di conservazione in Cloud Logging per soddisfare questi requisiti.
Prezzi e limiti di frequenza
Il grounding con i prezzi
Assicurati di esaminare i dettagli relativi a prezzi, disponibilità del modello e limiti per
Grounding con