Messa a terra con Google Maps

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

Il grounding con Google Maps presenta i seguenti vantaggi:

  • Aumenta l'accuratezza fattuale: riduci le allucinazioni del modello basando le risposte sul database di Google di oltre 250 milioni di luoghi e attività reali.
  • Accedi alle informazioni in tempo reale: rispondi alle domande utilizzando i dati in tempo reale, come gli orari di apertura attuali e lo stato in tempo reale delle stazioni di ricarica per auto elettriche.
  • Fornisci contesto visivo: crea fiducia negli utenti integrando widget di mappe interattive, foto e Street View direttamente accanto alle affermazioni del modello basate sulla posizione.

Modelli supportati

  • gemini-3.1-pro-preview
  • gemini-3-flash-preview
  • gemini-3.1-flash-lite
  • gemini-2.5-pro
  • gemini-2.5-flash
  • gemini-2.5-flash-lite

Lingue supportate

Consulta le lingue supportate per Gemini modelli.

Eseguire il grounding del modello con Google Maps

Fai clic sul tuo fornitore Gemini API per visualizzare contenuti specifici del fornitore e codice 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 adatti al tuo caso d'uso e alla tua app.

Per risultati ottimali, utilizza una temperatura di 1.0 (che è il valore predefinito per tutti i modelli Gemini 2.5 e versioni successive). Scopri come impostare la temperatura nella configurazione del modello.

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 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: informa chiaramente gli utenti finali che i dati Google Mapsvengono utilizzati per rispondere alle loro query. Fornire agli utenti finali le origini da Google Maps è un requisito di utilizzo del servizio per lo strumento di grounding con Google Maps.

  • (Solo SDK web) Esegui il rendering del widget contestuale Google Maps: il widget contestuale viene sottoposto a rendering utilizzando il token di contesto, googleMapsWidgetContextToken, che viene restituito nella rispostaGemini API e può essere utilizzato per eseguire il rendering dei contenuti visivi di Google Maps. Per saperne di più sul widget contestuale, consulta la sezione Widget di grounding con Google Maps widget nella documentazione.Google Maps

Utilizzare 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 risposte. Queste proprietà vengono utilizzate per determinare i tipi di domande a cui il grounding con Google Maps può rispondere.

Esempi di proprietà dei luoghi

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
  • Menù per bambini
  • Orario di apertura
  • Opzioni di pagamento (ad esempio contanti o carta di credito)
  • Risposta sui luoghi
  • Adatto agli animali
  • Serve birra
  • Serve cibo vegetariano
  • Accessibile in sedia a rotelle
  • Wi-Fi

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

Esempi di prompt che utilizzano le proprietà dei luoghi

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

  • Pianificare una cena in famiglia: determina se un ristorante è adatto a una famiglia e se offre un servizio conveniente.

    • Esempio di prompt: "The Italian Place" è adatto ai bambini e offre il servizio di asporto? Qual è la sua valutazione?

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

    • Esempio di prompt: Mi serve un ristorante con un ingresso accessibile alle sedie a rotelle.

  • Trovare un luogo per uno spuntino a tarda notte: trova un'attività aperta che serve un pasto specifico in un determinato momento.

    • Esempio di prompt: "Burger Joint" è aperto adesso? Serve la cena? Quali sono gli orari di apertura per venerdì?

  • Incontrare un cliente per un caffè: valuta l'idoneità di un bar per una riunione di lavoro in base ai servizi, alle offerte e alle opzioni di pagamento.

    • Esempio di prompt: "Cafe Central" ha il Wi-Fi? Serve caffè? Qual è il suo livello di prezzo e accetta carte di credito?

Tieni presente che le informazioni nei Google Maps risultati con grounding potrebbero differire dalle condizioni effettive della strada.

Come funziona il 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.

Di seguito è riportato il flusso di lavoro del modello:

  1. Riceve il 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 risposta, ad esempio se il prompt contiene un contesto geografico (come "bar vicino a me", "musei a San Francisco").

  3. Richiama lo strumento: il modello, riconoscendo l'intenzione geografica, 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 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 risultati più pertinenti e personalizzati Google Maps. Lo strumento è uno strumento di ricerca testuale e si comporta in modo simile alla ricerca su Google Maps, in quanto le query locali ("vicino a me") utilizzeranno le coordinate, mentre è improbabile che le query specifiche o non locali siano influenzate dalla località esplicita.

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

  6. Restituisce un Google Maps risultato con grounding: il modello restituisce una risposta finale, di facile utilizzo basata sui risultati Google Maps. Questa risposta include:

    • La risposta testuale del modello.
    • Un oggetto groundingMetadata con i risultati Google Maps e origini.
    • (Solo SDK web) Se vuoi, un googleMapsWidgetContextToken che ti consente di eseguire il rendering di un widget Google Maps contestuale nella tua app per l'interazione visiva. Per saperne di più sul widget contestuale, consulta la sezione Widget di grounding con Google Maps widget nella documentazione.Google Maps

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

Comprendere il risultato con grounding

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

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

  • groundingChunks: un array di oggetti contenenti le origini maps (uri, placeId e title).
  • groundingSupports: un array di blocchi per collegare il text della risposta del modello alle origini in groundingChunks. Ogni blocco collega un segment di testo (definito da startIndex e endIndex) a uno o più groundingChunkIndices. Questo campo ti aiuta a creare link di origine 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 eseguire il rendering di un widget contestuale di Places. Questo campo viene restituito solo quando si utilizza l'SDK web e se hai impostato il parametro enableWidget su true.

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 di utilizzo del servizio

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

Informare gli utenti delle origini Google Maps

Con ogni Google Maps risultato con grounding, riceverai le origini 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 origini Google Maps associate e informare gli utenti di quanto segue:

  • Le Google Maps origini devono seguire immediatamente i contenuti generati che supportano le origini. Questi contenuti generati sono anche chiamati Google Maps risultati con grounding.

  • Le origini Google Maps devono essere visualizzabili all'interno di un'interazione dell'utente.

Ecco come ottenere i valori per la visualizzazione delle origini dal Google Maps risultato con grounding:

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 origine in groundingChunks, è necessario generare un'anteprima del link che soddisfi i seguenti requisiti:

Prompt con risposta che mostra le fonti

Puoi comprimere la visualizzazione delle origini.

Prompt con risposta e fonti compresse

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

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

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

Linee guida per l'attribuzione del testo Google Maps

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

  • Non modificare in alcun modo il testo Google Maps:

    • Non modificare le lettere maiuscole del 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 del corpo sans-serif 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.
    Dimensioni carattere Dimensioni carattere minime: 12sp
    Dimensioni carattere massime: 16sp
    Per saperne di più su sp, consulta la sezione Unità di dimensioni dei caratteri sul sito web di Material Design.
    Spaziatura Normale

Esempio di CSS

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 Google Maps risultato con grounding può includere il token di contesto e l'ID luogo. Puoi memorizzare nella cache, archiviare ed esportare i seguenti dati di risposta:

  • (Solo SDK web) googleMapsWidgetContextToken
  • placeId

Le limitazioni 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 ulteriori limitazioni per determinati contenuti e attività al fine di mantenere una piattaforma sicura e affidabile. Oltre alle limitazioni di utilizzo nei Termini per il fornitore Gemini API scelto: Gemini Developer API o Vertex AI Gemini API (vedi Termini di servizio sezione all'interno dei Termini specifici dei servizi).

  • 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 la sezione Territori vietati di Google Maps Platform. L'elenco dei territori vietati può essere aggiornato di tanto in tanto.

Risultati con grounding e monitoraggio dell'AI nella console Firebase

Se hai attivato il monitoraggio dell'AI nella consoleFirebase, 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 completamente in linea con il tuo caso d'uso specifico e con eventuali requisiti di conformità aggiuntivi per il fornitore Gemini API scelto: Gemini Developer API o Vertex AI Gemini API (vedi Termini di servizio sezione all'interno dei Termini specifici dei servizi). Potresti dover modificare il periodo di conservazione in Cloud Logging per soddisfare questi requisiti.

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 Google Maps risultato con grounding (ovvero la risposta contiene almeno un'origine di Google Maps). Se vengono inviate più query a Google Maps da una singola richiesta, viene conteggiata come una richiesta ai fini del limite di frequenza.

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