The latest Gemini models, like Gemini 3.1 Flash Image (Nano Banana 2), are available to use with Firebase AI Logic! Learn more.

Gemini 2.0 Flash and Flash-Lite models will shut down on June 1, 2026. To avoid service disruption, update to a newer model like gemini-3.1-flash-lite. Learn more.

All Imagen models will shut down on June 24, 2026. Learn about migrating your apps to use Nano Banana.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Ancrage avec Google Maps

L'ancrage avec Google Maps associe un modèle Gemini à des 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 de 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 pour véhicules électriques.
Fournir 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 du modèle basées sur la localisation.

Modèles compatibles

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

Langues disponibles

Consultez les langues disponibles pour les modèles Gemini.

Ancrer le modèle avec Google Maps

Cliquez sur votre fournisseur Gemini API pour afficher le contenu spécifique au fournisseur et le code 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é à votre cas d'utilisation et à votre application.

Pour obtenir des résultats optimaux, utilisez une température de 1.0 (qui est la valeur par défaut pour tous les modèles Gemini 2.5 et versions ultérieures). Découvrez comment définir la température dans la configuration du modèle.

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 comment tirer parti des 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 accès à l'outil d'ancrage avec Google Maps que lorsque le cas d'utilisation présente un contexte géographique clair.
Fournissez 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 (à l'aide de la latitude et de la longitude via latLng) dans la configuration de l'outil d'ancrage avec Google Maps.
Informez 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 condition d'utilisation du service pour l'outil d'ancrage avec Google Maps.
(SDK Web uniquement) Affichez le widget contextuel Google Maps : le widget contextuel est affiché à l'aide du jeton de contexte googleMapsWidgetContextToken, qui est renvoyé dans la Gemini API réponse et peut être utilisé pour afficher du contenu visuel à partir de Google Maps. Pour en savoir plus sur le widget contextuel, consultez le widget d'ancrage avec Google Maps dans la documentation.Google Maps

Utiliser des propriétés de lieu dans les prompts

Cette section liste les propriétés de lieu utilisées pour décrire des lieux 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 de propriétés concernant 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 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 le lieu sont une réponse de l'ancrage avec Google Maps basée sur des informations provenant des avis des utilisateurs.

Exemples de prompts utilisant des propriétés de lieu

Les exemples suivants utilisent des propriétés de lieu dans des prompts 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 convient à une famille et s'il propose un service pratique.
- Exemple de prompt : Le restaurant "The Italian Place" est-il adapté aux 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 prompt : J'ai besoin d'un restaurant dont l'entrée est accessible aux fauteuils roulants.
Trouver un endroit pour une collation tardive : trouvez un établissement ouvert qui sert un repas spécifique à une heure précise.
- Exemple de prompt : Le "Burger Joint" est-il ouvert en ce moment ? Sert-il à dîner ? Quels sont ses horaires d'ouverture pour vendredi ?
Rencontrer un client pour prendre un café : évaluez si un café convient à une réunion professionnelle en fonction des équipements, des offres et des options de paiement.
- Exemple de prompt : Le "Café Central" dispose-t-il du Wi-Fi ? Sert-il du café ? Quel est son niveau de prix et accepte-t-il les cartes de crédit ?

Notez que les informations contenues 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 :

Reçoit le prompt : votre application envoie un prompt au modèle Gemini avec l'outil GoogleMaps activé.
Analyse le prompt : le modèle analyse le prompt et détermine si Google Maps peut améliorer sa réponse, par exemple si le prompt contient un contexte géographique (comme « cafés près de chez moi », « musées à San Francisco »).
Appelle l'outil : le modèle, reconnaissant l'intention géographique, appelle l'outil d'ancrage avec Google Maps.
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 le prompt) pour obtenir des résultats plus pertinents et personnalisés Google Maps Google Maps. L'outil est un outil de recherche textuelle et se comporte de la même manière que la recherche sur Google Maps. Les requêtes locales ("près de chez moi") utilisent les coordonnées, tandis que les requêtes spécifiques ou non locales sont peu susceptibles d'être influencées par l'emplacement explicite.
Traite les résultats Google Maps : le modèle traite les résultats Google Maps et formule une réponse au prompt d'origine.
Renvoie un Google Maps résultat ancré : le modèle renvoie une réponse finale, conviviale qui est ancrée dans les résultats Google Maps. Cette réponse inclut les éléments suivants :
- La réponse textuelle du modèle.
- Un objet groundingMetadata avec les résultats Google Maps et sources.
- (SDK Web uniquement) Éventuellement, un googleMapsWidgetContextToken qui vous permet d'afficher un widget contextuel Google Maps dans votre application pour une interaction visuelle. Pour en savoir plus sur le widget contextuel, consultez Ancrage avec Google Maps widget dans la documentation Google Maps.

Notez que fournir Google Maps comme outil au modèle ne nécessite pas que le modèle utilise toujours 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 Google Maps résultat ancré.

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 contenant 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 dans un Google Maps résultat ancré contient les informations suivantes :

groundingChunks: tableau d'objets contenant les sources maps (uri, placeId et title).
groundingSupports: tableau de blocs permettant de connecter la réponse text du modèle 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 de source intégrés. Découvrez comment respecter les conditions d'utilisation du service plus loin sur cette page.
(SDK Web uniquement) googleMapsWidgetContextToken : jeton de texte qui peut ê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 conditions d'utilisation du service pour l'ancrage avec Google Maps pour le fournisseur Gemini API que vous avez choisi : Gemini Developer API ou Vertex AI Gemini API (consultez 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 dans groundingChunks qui prennent en charge 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 de l'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 prennent en charge. 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
    }
  }
}

Afficher les sources Google Maps avec des liens Google Maps

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

Attribuez chaque source à Google Maps en suivant les Google Maps consignes d'attribution de texte.
Affichez le titre de la source fourni dans la réponse.
Créez un lien vers la source à l'aide de l'uri de la réponse.

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 également améliorer l'aperçu du lien avec du contenu supplémentaire, tel que :

Une Google Maps icône insérée avant l'Google Maps attribution de texte.
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 consignes d'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.
- N'insérez pas le texte Google Maps sur plusieurs lignes.
- 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".

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	N'importe quelle 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 minimale de la police : 12 sp Taille maximale de la police : 16 sp Pour en savoir plus sur les sp, consultez Unités de taille de police sur le site Web Material Design.
Espacement	Normal

Exemple d'élément 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 concernant la mise en cache dans les conditions d'utilisation de l'ancrage avec Google Maps ne s'appliquent pas à ces données.

Activités et territoires interdits

L'ancrage avec Google Maps comporte 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 du fournisseur que vous avez choisi : Gemini Developer API ou Vertex AI Gemini API (consultez la section Conditions d'utilisation du service dans les Conditions spécifiques du service).Gemini API

Vous n'utiliserez pas l'ancrage avec Google Maps pour des activités à haut risque y compris les services d'intervention 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 surveillance de l'IA dans la Firebase console

Si vous avez activé la surveillance de l'IA dans la consoleFirebase, 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 que vous avez choisi : Gemini Developer API ou Vertex AI Gemini API (consultez la section Conditions d'utilisation du service dans les Conditions spécifiques du service).Gemini API Vous devrez peut-être ajuster la période de conservation dans Cloud Logging pour répondre à ces exigences.

Tarifs et limites de débit

Les tarifs de l'ancrage avec Google Maps sont basés sur les requêtes. Une requête n'est comptabilisée dans le quota Google Maps que lorsqu'un prompt renvoie au moins un Google Maps résultat ancré (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 que vous avez choisi : Gemini Developer API | Vertex AI Gemini API.

Ancrage avec Google Maps Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Modèles compatibles

Langues disponibles

Ancrer le modèle avec Google Maps

Swift

Kotlin

Java

Web

Dart

Unity

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

Bonnes pratiques générales

Utiliser des propriétés de lieu dans les prompts

Exemples de propriétés de lieu

Exemples de prompts utilisant des propriétés de lieu

Fonctionnement de l'ancrage avec Google Maps

Comprendre le résultat ancré

Conditions d'utilisation du service

Informer les utilisateurs des sources Google Maps

Swift

Kotlin

Java

Web

Dart

Unity

Afficher les sources Google Maps avec des liens Google Maps

Google Maps consignes d'attribution de texte

Exemple d'élément CSS

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

Activités et territoires interdits

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

Tarifs et limites de débit

Ancrage avec Google Maps