Ancrage avec Google Maps

L'ancrage avec Google Maps permet d'associer un modèle Gemini aux données géospatiales de Google Maps afin que vous puissiez intégrer des fonctionnalités de localisation dans vos applications.

L'ancrage avec Google Maps présente les avantages suivants :

  • Améliorer la précision factuelle : réduisez les hallucinations du modèle en basant les réponses sur la base de données Google qui contient plus de 250 millions de lieux et d'entreprises réels.
  • Accédez à des informations en temps réel : répondez à des questions à l'aide de données en direct, comme les horaires d'ouverture actuels et l'état en temps réel des bornes de recharge de véhicules électriques.
  • Fournissez un contexte visuel : renforcez la confiance des utilisateurs en intégrant des widgets de carte interactifs, des photos et Street View directement à côté des affirmations basées sur la localisation du modèle.

Modèles compatibles

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

Langues disponibles

Consultez les langues acceptées pour les modèles Gemini.

Ancrer le modèle avec Google Maps

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Lorsque vous créez l'instance GenerativeModel, fournissez GoogleMaps en tant que tool que le modèle peut utiliser pour générer sa réponse.

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

Découvrez comment choisir un modèle adaptés à votre cas d'utilisation et à votre application.

Bonnes pratiques et conseils pour améliorer les résultats

Cette section décrit quelques bonnes pratiques générales pour utiliser l'ancrage avec Google Maps, ainsi que la façon d'exploiter les propriétés des lieux pour améliorer les résultats.

Bonnes pratiques générales

  • Ne fournissez l'outil que lorsque cela est nécessaire : pour optimiser les performances et les coûts, ne donnez accès au modèle à l'outil d'ancrage avec Google Maps que lorsque le cas d'utilisation présente un contexte géographique clair.

  • Indiquez la position de l'utilisateur : pour obtenir les réponses les plus pertinentes et personnalisées (et lorsque la position de l'utilisateur est connue), incluez la position de l'utilisateur (en utilisant la latitude et la longitude via latLng) dans la configuration de l'outil d'ancrage avec Google Maps.

  • Informez les utilisateurs finaux : indiquez clairement à vos utilisateurs finaux que les données Google Maps sont utilisées pour répondre à leurs requêtes. Fournir aux utilisateurs finaux les sources de Google Maps est une exigence d'utilisation du service pour l'outil d'ancrage avec Google Maps.

  • (SDK Web uniquement) Afficher le widget contextuel Google Maps : le widget contextuel est affiché à l'aide du jeton de contexte googleMapsWidgetContextToken, qui est renvoyé dans la réponse Gemini API et peut être utilisé pour afficher du contenu visuel à partir de Google Maps. Pour en savoir plus sur le widget contextuel, consultez Ancrage avec le widget Google Maps dans la documentation Google Maps.

Utiliser des propriétés de lieu dans les requêtes

Cette section liste les propriétés de lieu utilisées pour décrire des lieux et par l'ancrage avec Google Maps pour générer des réponses. Ces propriétés permettent de déterminer les types de questions auxquelles l'ancrage avec Google Maps peut répondre.

Exemples de propriétés de lieu

Cette liste fournit un échantillon alphabétique de propriétés sur les lieux que votre modèle peut utiliser pour générer des réponses.

  • Adresse
  • Drive disponible
  • Carte de débit
  • Distance
  • Parking gratuit
  • Concerts
  • Menu pour enfants
  • Horaires d'ouverture
  • Options de paiement (comme espèces ou carte de crédit)
  • Réponse sur le lieu
  • Animaux acceptés
  • Bière
  • Sert des plats végétariens
  • Accessible en fauteuil roulant
  • Wi-Fi

Les réponses sur les lieux sont des réponses d'ancrage avec Google Maps basées sur des informations issues des avis des utilisateurs.

Exemples de requêtes utilisant des propriétés de lieu

Les exemples suivants utilisent des propriétés de lieu dans des requêtes concernant différents types de lieux. L'ancrage avec Google Maps utilise les propriétés pour comprendre votre intention, puis fournit des réponses pertinentes en fonction des données associées aux lieux dans Google Maps.

  • Planifier un dîner en famille : déterminer si un restaurant convient à une famille et s'il propose un service adapté.

    • Exemple de requête : "The Italian Place" est-il un bon restaurant pour les enfants et propose-t-il des plats à emporter ? Quelle est sa note ?

  • Vérifier l'accessibilité pour un ami : déterminez si le lieu répond à des besoins d'accessibilité spécifiques.

    • Exemple de requête : J'ai besoin d'un restaurant avec une entrée accessible en fauteuil roulant.

  • Trouver un endroit où manger un en-cas tardif : trouvez un établissement ouvert servant un repas spécifique à une heure précise.

    • Exemple de requête : "Burger Joint" est-il ouvert en ce moment ? Sert-il à dîner ? Quels sont leurs horaires d'ouverture pour vendredi ?

  • Prendre un café avec un client : évaluez si un café convient pour une réunion d'affaires en fonction des services, des offres et des options de paiement.

    • Exemple de requête : Le "Café Central" dispose-t-il d'une connexion Wi-Fi ? Sert-il du café ? Quel est leur niveau de prix et acceptent-ils les cartes de crédit ?

Notez que les informations fournies dans les Google Maps résultats ancrés peuvent différer des conditions réelles de la route.

Fonctionnement de l'ancrage avec Google Maps

Lorsque vous fournissez l'outil GoogleMaps au modèle, celui-ci gère automatiquement l'ensemble du workflow de recherche, de traitement et de citation des informations.

Voici le workflow du modèle :

  1. Reçoit le prompt : votre application envoie un prompt au modèle Gemini avec l'outil GoogleMaps activé.

  2. Analyse de la requête : le modèle analyse la requête et détermine si Google Maps peut améliorer sa réponse, par exemple si la requête contient un contexte géographique (comme "cafés près de chez moi" ou "musées à San Francisco").

  3. Appel de l'outil : le modèle, qui reconnaît l'intention géographique, appelle l'outil Google Maps.

  4. Envoie des requêtes à Google Maps : le service d'ancrage avec Google Maps interroge Google Maps pour obtenir des informations pertinentes (par exemple, des lieux, des avis, des photos, des adresses, des horaires d'ouverture).

    Vous pouvez éventuellement inclure la latitude et la longitude dans la configuration de l'outil (ou même directement dans la requête) pour obtenir des résultats Google Maps plus pertinents et personnalisés. Cet outil de recherche textuelle fonctionne de la même manière que la recherche sur Google Maps. Les requêtes locales ("près de moi") utilisent les coordonnées, tandis que les requêtes spécifiques ou non locales sont peu susceptibles d'être influencées par la position explicite.

  5. Traite les résultats Google Maps : le modèle traite les résultats Google Maps et formule une réponse à la requête d'origine.

  6. Renvoie un Google Maps résultat ancré : le modèle renvoie une réponse finale et conviviale, ancrée dans les résultats Google Maps. Cette réponse inclut les éléments suivants :

    • Réponse textuelle du modèle.
    • Objet groundingMetadata avec les résultats et les sources Google Maps.
    • (SDK Web uniquement) Vous pouvez éventuellement utiliser un googleMapsWidgetContextToken qui vous permet d'afficher un widget Google Maps contextuel dans votre application pour une interaction visuelle. Pour en savoir plus sur le widget contextuel, consultez Ancrage avec le widget Google Maps dans la documentation Google Maps.

Notez que le fait de fournir Google Maps comme outil au modèle n'oblige pas le modèle à toujours utiliser l'outil Google Maps pour générer sa réponse. Dans ce cas, la réponse ne contient pas d'objet groundingMetadata et n'est donc pas un résultat ancré Google Maps.

Comprendre le résultat ancré

Si le modèle ancre sa réponse dans les résultats Google Maps, la réponse inclut un objet groundingMetadata qui contient des données structurées essentielles pour vérifier les affirmations et créer une expérience de source enrichie dans votre application.

L'objet groundingMetadata d'un résultat ancré Google Maps contient les informations suivantes :

  • groundingChunks : tableau d'objets contenant les sources maps (uri, placeId et title).
  • groundingSupports : tableau de blocs permettant de relier la réponse du modèle text aux sources dans groundingChunks. Chaque bloc associe un segment de texte (défini par startIndex et endIndex) à un ou plusieurs groundingChunkIndices. Ce champ vous permet de créer des liens vers la source en ligne. Découvrez comment respecter les exigences d'utilisation des services plus loin sur cette page.
  • (SDK Web uniquement) googleMapsWidgetContextToken : jeton de texte pouvant être utilisé pour afficher un widget Places contextuel. Ce champ n'est renvoyé que lorsque vous utilisez le SDK Web et si vous avez défini le paramètre enableWidget sur true.

Voici un exemple de réponse incluant un objet 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/..."
      }
    }
  ]
}

Conditions d'utilisation du service

Cette section décrit les exigences d'utilisation du service pour l'ancrage avec Google Maps pour le fournisseur Gemini API de votre choix : Gemini Developer API ou Vertex AI Gemini API (voir la section Conditions d'utilisation du service dans les Conditions spécifiques du service).

Informer les utilisateurs des sources Google Maps

Pour chaque Google Maps résultat ancré, vous recevrez des sources en groundingChunks qui étayent chaque réponse. Les métadonnées suivantes sont également renvoyées :

  • URI source
  • title
  • ID

Dans votre application, lorsque vous présentez des résultats d'ancrage avec Google Maps, vous devez spécifier les sources Google Maps associées et informer vos utilisateurs des points suivants :

  • Les sources Google Maps doivent suivre immédiatement le contenu généré qu'elles soutiennent. Ce contenu généré est également appelé Google Maps résultat ancré.

  • Les sources Google Maps doivent être visibles en une seule interaction de l'utilisateur.

Voici comment obtenir des valeurs pour afficher les sources à partir du Google Maps résultat ancré :

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

Pour chaque source dans groundingChunks, un aperçu du lien doit être généré en respectant les exigences suivantes :

Requête avec réponse affichant les sources

Vous pouvez réduire l'affichage des sources.

Requête avec réponse et sources réduites

Vous pouvez éventuellement enrichir l'aperçu du lien avec du contenu supplémentaire, par exemple :

  • Un Google Maps favicon inséré avant l'attribution de texte Google Maps.
  • Photo provenant de l'URL source (og:image).

Pour en savoir plus sur certains fournisseurs de données Google Maps et leurs conditions de licence, consultez les mentions légales de Google Maps et Google Earth.

Consignes concernant l'attribution de texte Google Maps

Lorsque vous attribuez des sources à Google Maps dans un texte, suivez ces consignes :

  • Ne modifiez en aucun cas le texte Google Maps :

    • Ne modifiez pas la casse du texte Google Maps.
    • Ne pas renvoyer le texte Google Maps à la ligne.
    • Ne traduisez pas le texte Google Maps dans une autre langue.
    • Empêchez les navigateurs de traduire le texte Google Maps en utilisant l'attribut HTML translate="no".

  • Mettez en forme le texte Google Maps comme décrit dans le tableau suivant :

    Propriété Style
    Famille de polices Roboto. Le chargement de la police est facultatif.
    Famille de polices de remplacement Toute police de corps sans empattement déjà utilisée dans votre produit ou "Sans-Serif" pour appeler la police système par défaut
    Style de police Normal
    Épaisseur de la police 400
    Couleur de police Blanc, noir (#1F1F1F) ou gris (#5E5E5E). Maintenez un contraste accessible (4,5:1) par rapport à l'arrière-plan.
    Taille de police Taille de police minimale : 12 sp
    Taille de police maximale : 16 sp
    Pour en savoir plus sur les sp, consultez la section "Unités de taille de police" sur le site Web Material Design.
    Espacement Normal

Exemple de CSS

L'élément CSS suivant affiche le texte Google Maps avec le style typographique et la couleur appropriés sur un arrière-plan clair ou blanc.

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

Mise en cache du jeton de contexte et de l'ID de lieu

Le Google Maps résultat ancré peut inclure un jeton de contexte et un ID de lieu. Vous pouvez mettre en cache, stocker et exporter les données de réponse suivantes :

  • (SDK Web uniquement) googleMapsWidgetContextToken
  • placeId

Les restrictions de mise en cache des conditions d'utilisation de l'ancrage avec Google Maps ne s'appliquent pas à ces données.

Activité et territoires interdits

L'ancrage avec Google Maps est soumis à des restrictions supplémentaires pour certains contenus et activités afin de maintenir une plate-forme sûre et fiable. En plus des restrictions d'utilisation dans les conditions d'utilisation de votre fournisseur Gemini API : Gemini Developer API ou Vertex AI Gemini API (voir la section Conditions d'utilisation du service dans les conditions spécifiques au service).

  • Vous n'utiliserez pas l'ancrage avec Google Maps pour les activités à haut risque, y compris les services d'urgence.

  • Vous ne distribuerez ni ne commercialiserez votre application qui propose l'ancrage avec Google Maps dans un Territoire interdit. Pour en savoir plus, consultez Territoires interdits sur Google Maps Platform. La liste des territoires interdits peut être mise à jour de temps en temps.

Résultats ancrés et surveillance de l'IA dans la console Firebase

Si vous avez activé AI monitoring dans la console Firebase, les réponses sont stockées dans Cloud Logging. Par défaut, ces données ont une période de conservation de 30 jours.

Il vous incombe de vous assurer que cette période de conservation, ou toute période personnalisée que vous définissez, correspond parfaitement à votre cas d'utilisation spécifique et à toute exigence de conformité supplémentaire pour le fournisseur Gemini API de votre choix : Gemini Developer API ou Vertex AI Gemini API (voir la section Conditions d'utilisation du service dans les Conditions spécifiques aux services). Vous devrez peut-être ajuster la période de conservation dans Cloud Logging pour répondre à ces exigences.

Tarifs et limites de débit

La tarification de l'ancrage avec Google Maps est basée sur les requêtes. Une requête n'est comptabilisée dans le quota de Google Maps que lorsqu'une requête renvoie au moins un résultat ancré Google Maps (c'est-à-dire que la réponse contient au moins une source Google Maps). Si plusieurs requêtes sont envoyées à Google Maps à partir d'une même requête, elles comptent pour une seule requête dans la limite de fréquence.

Veillez à consulter les informations sur les tarifs, la disponibilité des modèles et les limites de l'ancrage avec Google Maps dans la documentation du fournisseur Gemini API de votre choix : Gemini Developer API | Vertex AI Gemini API.