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 détection de la position 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 de Google, qui contient plus de 250 millions de lieux et d'entreprises réels.
  • Accéder à des informations en temps réel : répondez aux questions à l'aide de données en direct, telles que les horaires d'ouverture actuels et l'état en temps réel des bornes de recharge de VE.
  • Fournir des sources : renforcez la confiance des utilisateurs en affichant les sources et les liens de Google Maps lieux directement à côté des affirmations du modèle basées sur la localisation.

Modèles compatibles

  • gemini-4-argon
  • gemini-3.8-flash (et les versions plus anciennes gemini-3.7-flash, gemini-3.6-flash et gemini-3.5-flash)
  • gemini-3.5-flash-lite (et l'ancien gemini-3.1-flash-lite)

Les modèles gemini-3.1-pro-preview et Gemini 2.5 à usage général (qui sont obsolètes) sont également compatibles avec cette fonctionnalité.

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

Découvrez comment choisir un modèle adapté à 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 manière d'exploiter les propriétés de lieu 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 au modèle l'accès à l'outil d'ancrage avec Google Maps que lorsque le cas d'utilisation présente un contexte géographique clair.

  • Fournir 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.

  • Informer les utilisateurs finaux : informez 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.

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

Cette section liste les propriétés de lieu utilisées pour décrire des emplacements et utilisées 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 des propriétés des 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 enfant
  • Horaires d'ouverture
  • Modes de paiement (espèces ou carte de crédit, par exemple)
  • Réponse sur le lieu
  • Accepte les animaux
  • Bière
  • Sert des plats végétariens
  • Accessible en fauteuil roulant
  • Wi-Fi

Les réponses sur les lieux sont une réponse de l'ancrage avec Google Maps basée 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éterminez si un restaurant est adapté aux familles et s'il propose un service pratique.

    • Exemple de prompt : Est-ce que "The Italian Place" est adapté aux enfants et propose des plats à emporter ? Quelle est leur note ?

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

    • Exemple de prompt : Je cherche un restaurant avec une entrée accessible en fauteuil roulant.

  • Trouver un endroit où manger tard le soir : trouvez un établissement ouvert qui sert un repas spécifique à une heure précise.

    • Exemple de requête : Est-ce que "Burger Joint" est ouvert ? Est-ce qu'on y sert le dîner ? Quels sont ses horaires d'ouverture le vendredi ?

  • Rencontrer un client dans un café : évaluez si un café est adapté à une réunion professionnelle en fonction des services, des offres et des modes de paiement.

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

Notez que les informations contenues dans les résultats ancrés Google Maps 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. Réception du 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 à proximité", "musées à San Francisco").

  3. Appelle l'outil : le modèle, reconnaissant l'intention géographique, appelle l'outil d'ancrage avec 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. L'outil est un outil de recherche textuelle et se comporte de la même manière qu'une recherche sur Google Maps, dans la mesure où les requêtes locales ("à proximité") utiliseront les coordonnées, tandis que les requêtes spécifiques ou non locales ne seront probablement pas 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 au prompt d'origine.

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

    • Réponse textuelle du modèle.
    • Un objet groundingMetadata avec les résultats et les sources Google Maps.

Notez que le fait de fournir Google Maps en tant qu'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 contiendra pas d'objet groundingMetadata et ne sera donc pas un résultat ancré Google Maps.

Comprendre le résultat ancré

Si le modèle fonde sa réponse sur les résultats de Google Maps, la réponse inclut un objet groundingMetadata contenant des données structurées essentielles pour vérifier les affirmations et créer une expérience de source riche 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 fragments permettant de connecter la réponse du modèle text aux sources dans groundingChunks. Chaque fragment associe un segment de texte segment (défini par startIndex et endIndex) à un ou plusieurs groundingChunkIndices. Ce champ vous aide à créer des liens vers des sources intégrées. Découvrez comment répondre aux exigences d'utilisation du service plus loin sur cette page.

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

Exigences d'utilisation du service

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

Informer les utilisateurs des sources de Google Maps

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

  • URI source
  • titre
  • ID

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

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

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

Voici comment obtenir les valeurs permettant d'afficher les sources à partir du résultat d'ancrage Google Maps :

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é conformément aux exigences suivantes :

Prompt avec réponse affichant les sources

Vous pouvez réduire la vue des sources.

Prompt avec réponse et sources réduites

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

  • Un favicon Google Maps inséré avant l'attribution de texte Google Maps.
  • Une photo 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.

Google Maps consigne concernant l'attribution de texte

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

  • Ne modifiez en aucun cas le texte Google Maps :

    • Ne modifiez pas la casse du texte Google Maps.
    • Ne renvoyez pas 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 à l'aide de l'attribut HTML translate="no".

  • Appliquez un style au 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 sur les unités de taille de police sur le site Web Material Design.
    Espacement Normal

Exemple d'élément CSS

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

@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 de l'ID de lieu

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

  • placeId

Les restrictions concernant la mise en cache dans les conditions d'ancrage avec Google Maps ne s'appliquent pas à ces données.

Activités 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 énoncées dans les Conditions d'utilisation du fournisseur Gemini API que vous avez choisi : Gemini Developer API ou Agent Platform Gemini API (formerly Vertex AI) (voir la section Conditions d'utilisation du service dans les Conditions d'utilisation spécifiques du service).

  • Vous n'utiliserez pas l'ancrage avec Google Maps pour des 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 à autre.

Résultats ancrés et AI Monitoring dans la console Firebase

Si vous avez activé l'AI Monitoring dans la console Firebase, les réponses sont stockées dans Cloud Logging. Par défaut, ces données sont conservées pendant 30 jours.

Il vous incombe de vous assurer que cette durée de conservation, ou toute durée personnalisée que vous définissez, correspond parfaitement à votre cas d'utilisation spécifique et à toutes les exigences de conformité supplémentaires pour le fournisseur Gemini API que vous avez choisi : Gemini Developer API ou Agent Platform Gemini API (formerly Vertex AI) (voir la section Conditions d'utilisation du service dans les Conditions spécifiques au service). Vous devrez peut-être ajuster la durée 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 Google Maps que lorsqu'un prompt renvoie au moins un résultat ancré Google Maps (ce qui signifie que la réponse contient au moins une source Google Maps). Si plusieurs requêtes sont envoyées à Google Maps à partir d'une seule requête, elles sont comptabilisées comme une seule requête dans la limite de débit.

Veillez à consulter les détails 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 | Agent Platform Gemini API (formerly Vertex AI).