Grounding con Google Maps

Il grounding con Google Maps collega un modello Gemini ai dati geospaziali di Google Maps, in modo da poter integrare nelle tue app funzionalità basate sulla posizione.

Il grounding con Google Maps offre i seguenti vantaggi:

  • Aumenta l'accuratezza oggettiva: 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, come l'orario di apertura attuale e lo stato in tempo reale delle stazioni di ricarica EV.
  • Fornisci le fonti: aumenta la fiducia degli utenti mostrando Google Maps fonti e link dei luoghi direttamente accanto alle affermazioni basate sulla posizione del modello.

Modelli supportati

  • gemini-4-argon
  • gemini-3.8-flash (e i modelli precedenti gemini-3.7-flash, gemini-3.6-flash e gemini-3.5-flash)
  • gemini-3.5-flash-lite (e il precedente gemini-3.1-flash-lite)

Anche i modelli gemini-3.1-pro-preview e Gemini 2.5 per uso generico (deprecati) supportano questa funzionalità.

Lingue supportate

Consulta le lingue supportate per i modelli Gemini.

Fonda il modello con Google Maps

Fai clic sul tuo provider Gemini API per visualizzare i contenuti e il codice specifici del provider in questa pagina.

Quando crei l'istanza GenerativeModel, fornisci GoogleMaps come tool che il modello può utilizzare per generare la risposta.

Swift 


import CoreLocation
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: [.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.
    tools: [ { googleMaps: {} } ],
    // 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-US',
  ),
);

// 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 del grounding con Google Maps, nonché come sfruttare le proprietà dei luoghi per migliorare i risultati.

Best practice generali

  • Fornisci lo strumento solo quando necessario: per ottimizzare le prestazioni e i costi, fornisci al modello l'accesso allo strumento di grounding con Google Maps solo quando il caso d'uso ha un contesto geografico chiaro.

  • Fornisci la posizione dell'utente: per ottenere 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 di grounding con Google Maps.

  • Informa gli utenti finali: comunica chiaramente agli utenti finali che i dati di Google Maps vengono utilizzati per rispondere alle loro query. Fornire agli utenti finali le fonti di Google Maps è un requisito di utilizzo del servizio per lo strumento Grounding con Google Maps.

Utilizza le proprietà dei luoghi nei prompt

Questa sezione elenca le proprietà dei luoghi utilizzate per descrivere le località e utilizzate dal grounding con Google Maps per generare le risposte. Queste proprietà vengono utilizzate per determinare i tipi di domande a cui Grounding con Google Maps può rispondere.

Proprietà dei luoghi di esempio

Questo elenco fornisce un esempio 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 esempio contanti o carta di credito)
  • Risposta sui luoghi
  • Sicuri per animali
  • Serve birra
  • Serve cibo vegetariano
  • Accessibile in sedia a rotelle
  • Wi-Fi

Le risposte sui luoghi sono una risposta di Grounding con Google Maps basata su informazioni derivate dalle recensioni degli utenti.

Prompt di esempio che utilizzano le proprietà dei luoghi

I seguenti esempi utilizzano le proprietà dei luoghi nei prompt relativi a diversi tipi di luoghi. Il grounding con Google Maps utilizza le proprietà per comprendere il tuo intent e poi fornisce risposte pertinenti in base ai dati associati ai luoghi in Google Maps.

  • Pianifica una cena in famiglia: determina se un ristorante è adatto alle famiglie e se offre un servizio conveniente.

    • Prompt di esempio: "The Italian Place" è adatto ai bambini e offre il servizio di asporto? Qual è la loro valutazione?

  • Verifica l'accessibilità per un amico: determina se la località soddisfa esigenze di accessibilità specifiche.

    • Prompt di esempio: Ho bisogno di un ristorante con un ingresso accessibile in sedia a rotelle.

  • Trova un posto dove fare uno spuntino a tarda notte: trova un'attività aperta che serve un pasto specifico in un determinato orario.

    • Prompt di esempio: "Burger Joint" è aperto adesso? Servono la cena? Quali sono gli orari di apertura di venerdì?

  • Incontra 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: "Cafe Central" ha il Wi-Fi? Servono caffè? Qual è il loro livello di prezzo e accettano carte di credito?

Tieni presente che le informazioni contenute nei Google Maps risultati basati su dati reali potrebbero differire dalle condizioni effettive della strada.

Come funziona il grounding con Google Maps

Quando fornisci al modello lo strumento GoogleMaps, il modello gestisce l'intero flusso di lavoro di ricerca, elaborazione e citazione delle informazioni in modo automatico.

Ecco il flusso di lavoro del modello:

  1. Ricezione del prompt: la tua app invia un prompt al modello Gemini con lo strumento GoogleMaps abilitato.

  2. 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 nelle vicinanze", "musei a San Francisco").

  3. Richiama lo strumento: il modello, riconoscendo l'intent geografico, richiama lo strumento di grounding con Google Maps.

  4. Invia query a Google Maps: il servizio di grounding con Google Maps esegue query su Google Maps per ottenere informazioni pertinenti (ad esempio luoghi, recensioni, foto, indirizzi, orari di apertura).

    Se vuoi, puoi includere latitudine e longitudine nella configurazione dello strumento (o anche solo direttamente nel prompt) per ottenere risultati Google Maps più pertinenti e personalizzati. Lo strumento è uno strumento di ricerca testuale e si comporta in modo simile alla ricerca su Google Maps, in quanto le query locali ("nelle vicinanze") utilizzeranno le coordinate, mentre è improbabile che le query specifiche o non locali siano influenzate dalla posizione esplicita.

  5. Elabora i risultati di Google Maps: il modello elabora i risultati di Google Maps e formula una risposta al prompt originale.

  6. Restituisce un Risultato fondato di Google Maps: il modello restituisce una risposta finale facile da usare basata sui risultati di Google Maps. Questa risposta include:

    • La risposta di testo del modello.
    • Un oggetto groundingMetadata con i risultati e le fonti di Google Maps.

Tieni presente che fornire Google Maps come strumento al modello non richiede al modello di utilizzare sempre lo strumento Google Maps per generare la sua risposta. In questi casi, la risposta non conterrà un oggetto groundingMetadata e, di conseguenza, non è un risultato con grounding di Google Maps.

Comprendi il risultato basato sui dati

Se il modello basa la sua risposta sui risultati di Google Maps, la risposta include un oggetto groundingMetadata che contiene dati strutturati essenziali per verificare le affermazioni e creare un'esperienza di origine completa nella tua applicazione.

L'oggetto groundingMetadata in un risultato con grounding di Google Maps contiene le seguenti informazioni:

  • groundingChunks: un array di oggetti contenenti le origini maps (uri, placeId e title).
  • groundingSupports: un array di chunk per collegare la risposta del modello text alle fonti in groundingChunks. Ogni segmento collega un testo segment (definito da startIndex e endIndex) 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.

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]
          }
        ]
      }
    }
  ]
}

Requisiti per l'utilizzo del servizio

Questa sezione descrive i requisiti di utilizzo del servizio per il grounding con Google Maps per il provider Gemini API scelto: Gemini Developer API o Agent Platform Gemini API (formerly Vertex AI) (consulta la sezione Termini di servizio all'interno dei Termini specifici dei servizi).

Informare gli utenti delle fonti di Google Maps

Con ogni Google Maps risultato basato su dati, riceverai fonti in groundingChunks che supportano ogni risposta. Vengono restituiti anche i seguenti metadati:

  • URI di origine
  • titolo
  • ID

Nella tua app, quando presenti i risultati del grounding con Google Maps, devi specificare le fonti Google Maps associate e informare gli utenti di quanto segue:

  • Le fonti Google Maps devono seguire immediatamente i contenuti generati che supportano. Questi contenuti generati sono anche chiamati Google Maps Grounded Result.

  • Le fonti Google Maps devono essere visualizzabili nell'ambito di un'unica interazione dell'utente.

Ecco come ottenere i valori per la visualizzazione delle fonti dal Google Maps Grounded Result:

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
    }
  }
}

Per ogni fonte in groundingChunks, deve essere generata un'anteprima del link che rispetti i seguenti requisiti:

Prompt con risposta che mostra le fonti

Puoi comprimere la visualizzazione delle fonti.

Prompt con risposta e fonti compresse

Se vuoi, puoi migliorare l'anteprima del link con contenuti aggiuntivi, ad esempio:

  • Una favicon Google Maps inserita prima dell'attribuzione del testo Google Maps.
  • Una foto dall'URL di origine (og:image).

Per saperne di più su alcuni dei fornitori di dati di Google Maps e sui loro termini di licenza, consulta le note legali di Google Maps e Google Earth.

Linee guida per l'attribuzione del testo di Google Maps

Quando attribuisci le fonti a Google Maps all'interno del testo, segui queste linee guida:

  • Non modificare in alcun modo il testo Google Maps:

    • Non modificare l'uso delle maiuscole nel testo Google Maps.
    • Non mandare a capo il testo Google Maps su più righe.
    • Non localizzare il testo Google Maps in un'altra lingua.
    • Impedisci ai browser di tradurre il testo Google Maps utilizzando l'attributo HTML translate="no".

  • Applica lo stile al testo Google Maps come descritto nella tabella seguente:

    Proprietà Stile
    Famiglia di caratteri Roboto. Il caricamento del carattere è facoltativo.
    Famiglia di caratteri di riserva Qualsiasi carattere sans serif per il corpo già utilizzato nel tuo prodotto o "Sans-Serif" per richiamare il carattere di sistema predefinito
    Stile carattere Normale
    Spessore carattere 400
    Colore carattere Bianco, nero (#1F1F1F) o grigio (#5E5E5E). Mantieni un contrasto accessibile (4,5:1) rispetto allo sfondo.
    Dimensione carattere Dimensione minima del carattere: 12 sp
    Dimensione massima del carattere: 16 sp
    Per scoprire di più su sp, consulta le unità di dimensione dei caratteri sul sito web di Material Design.
    Spaziatura Normale

CSS di esempio

Il seguente CSS mostra il 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 dell'ID luogo

Il risultato con grounding Google Maps potrebbe includere un ID luogo. Puoi memorizzare nella cache, archiviare ed esportare i seguenti dati di risposta:

  • placeId

Le limitazioni relative alla memorizzazione nella cache nei Termini di Grounding con Google Maps non si applicano a questi dati.

Attività e territori vietati

Il grounding con Google Maps prevede limitazioni aggiuntive per determinati contenuti e attività per mantenere una piattaforma sicura e affidabile. Oltre alle limitazioni di utilizzo previste dai Termini per il provider Gemini API scelto: Gemini Developer API o Agent Platform Gemini API (formerly Vertex AI) (consulta la sezione Termini di servizio dei Termini specifici del servizio).

  • Non utilizzerai il grounding con Google Maps per attività ad alto rischio, inclusi i servizi di risposta alle emergenze.

  • Non distribuirai né commercializzerai la tua applicazione che offre il grounding con Google Maps in un Territorio vietato. Per saperne di più, consulta 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 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 provider Gemini API scelto: Gemini Developer API o Agent Platform Gemini API (formerly Vertex AI) (consulta la sezione Termini di servizio all'interno dei Termini specifici dei servizi). Per soddisfare questi requisiti, potrebbe essere necessario modificare il periodo di conservazione in Cloud Logging.

Prezzi e limiti di frequenza

I prezzi del grounding con Google Maps si basano sulle query. Una richiesta viene conteggiata ai fini della quota di Google Maps solo quando un prompt restituisce correttamente almeno un risultato con grounding di Google Maps (ovvero la risposta contiene almeno una fonte Google Maps). Se vengono inviate più query a Google Maps da una singola richiesta, questa viene conteggiata come una sola richiesta ai fini della limitazione di frequenza.

Assicurati di esaminare i dettagli relativi a prezzi, disponibilità dei modelli e limiti per il grounding con Google Maps nella documentazione del provider Gemini API scelto: Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI).