Ancrage avec Google Maps

L'ancrage avec Google Maps permet d'associer les capacités génératives de Gemini aux données riches, factuelles et à jour de Google Maps. Cette fonctionnalité permet aux développeurs d'intégrer facilement des fonctionnalités de localisation dans leurs applications. Lorsqu'une requête utilisateur comporte un contexte lié aux données Maps, le modèle Gemini s'appuie sur Google Maps pour fournir des réponses factuelles et à jour, pertinentes pour la zone ou la région spécifiée par l'utilisateur.

• Des réponses précises et adaptées à la localisation : exploitez les données actuelles et exhaustives de Google Maps pour les requêtes géographiques spécifiques.
• Personnalisation améliorée : personnalisez les recommandations et les informations en fonction des lieux fournis par les utilisateurs.
• Informations et widgets contextuels : jetons de contexte permettant d'afficher des widgets Google Maps interactifs à côté du contenu généré.

Commencer

Cet exemple montre comment intégrer l'ancrage avec Google Maps dans votre application pour fournir des réponses précises et géolocalisées aux requêtes des utilisateurs. La requête demande des recommandations locales avec une position de l'utilisateur facultative, ce qui permet au modèle Gemini d'exploiter les données Google Maps.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "What are the best Italian restaurants within a 15-minute walk from here?"

response = client.models.generate_content(
    model='gemini-2.5-flash-lite',
    contents=prompt,
    config=types.GenerateContentConfig(
        # Turn on grounding with Google Maps
        tools=[types.Tool(google_maps=types.GoogleMaps())],
        # Optionally provide the relevant location context (this is in Los Angeles)
        tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
            lat_lng=types.LatLng(
                latitude=34.050481, longitude=-118.248526))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in grounding.grounding_chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')

import { GoogleGenAI } from "@google/gnai";

const ai = new GoogleGenAI({});

async function generateContentWithMapsGrounding() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: "What are the best Italian restaurants within a 15-minute walk from here?",
    config: {
      // Turn on grounding with Google Maps
      tools: [{ googleMaps: {} }],
      toolConfig: {
        retrievalConfig: {
          // Optionally provide the relevant location context (this is in Los Angeles)
          latLng: {
            latitude: 34.050481,
            longitude: -118.248526,
          },
        },
      },
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const grounding = response.candidates[0]?.groundingMetadata;
  if (grounding?.groundingChunks) {
    console.log("-".repeat(40));
    console.log("Sources:");
    for (const chunk of grounding.groundingChunks) {
      if (chunk.maps) {
        console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
      }
    }
  }
}

generateContentWithMapsGrounding();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "What are the best Italian restaurants within a 15-minute walk from here?"
    }]
  }],
  "tools": [{"googleMaps": {}}],
  "toolConfig": {
    "retrievalConfig": {
      "latLng": {"latitude": 34.050481, "longitude": -118.248526}
    }
  }
}'

Fonctionnement de l'ancrage avec Google Maps

L'ancrage avec Google Maps intègre l'API Gemini à l'écosystème Google Geo en utilisant l'API Maps comme source d'ancrage. Lorsque la requête d'un utilisateur contient un contexte géographique, le modèle Gemini peut appeler l'outil d'ancrage avec Google Maps. Le modèle peut ensuite générer des réponses ancrées dans les données Google Maps pertinentes pour le lieu fourni.

Le processus implique généralement les étapes suivantes :

1. Requête utilisateur : un utilisateur envoie une requête à votre application, qui peut inclure un contexte géographique (par exemple, "cafés à proximité", "musées à San Francisco").
2. Invocation de l'outil : le modèle Gemini, qui reconnaît l'intention géographique, invoque l'outil d'ancrage avec Google Maps. Cet outil peut éventuellement être fourni avec les latitude et longitude de l'utilisateur pour obtenir des résultats tenant compte de la position.
3. Récupération des données : 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 ou des horaires d'ouverture).
4. Génération ancrée : les données Maps récupérées sont utilisées pour étayer la réponse du modèle Gemini, ce qui garantit l'exactitude et la pertinence des faits.
5. Jeton de réponse et de widget : le modèle renvoie une réponse textuelle, qui inclut des citations de sources Google Maps. La réponse de l'API peut également contenir un google_maps_widget_context_token, ce qui permet aux développeurs d'afficher un widget Google Maps contextuel dans leur application pour une interaction visuelle.

Pourquoi et quand utiliser l'ancrage avec Google Maps

L'ancrage avec Google Maps est idéal pour les applications qui nécessitent des informations précises, à jour et spécifiques à un lieu. Elle améliore l'expérience utilisateur en fournissant des contenus pertinents et personnalisés, grâce à la vaste base de données Google Maps qui compte plus de 250 millions de lieux dans le monde entier.

Vous devez utiliser l'ancrage avec Google Maps lorsque votre application doit :

• Fournissez des réponses complètes et précises aux questions spécifiques à une zone géographique.
• Créez des planificateurs de voyages et des guides locaux conversationnels.
• Recommander des points d'intérêt en fonction de la position et des préférences de l'utilisateur (restaurants ou magasins, par exemple)
• Créez des expériences basées sur la localisation pour les services sociaux, de vente au détail ou de livraison de repas.

L'ancrage avec Google Maps excelle dans les cas d'utilisation où la proximité et les données factuelles actuelles sont essentielles, comme pour trouver le "meilleur café à proximité" ou obtenir un itinéraire.

Méthodes et paramètres de l'API

L'ancrage avec Google Maps est exposé via l'API Gemini en tant qu'outil dans la méthode generateContent. Pour activer et configurer l'ancrage avec Google Maps, incluez un objet googleMaps dans le paramètre tools de votre requête.

{
  "contents": [{
    "parts": [
      {"text": "Restaurants near Times Square."}
    ]
  }],
  "tools":  { "googleMaps": {} }
}

L'outil googleMaps peut également accepter un paramètre booléen enableWidget, qui permet de contrôler si le champ googleMapsWidgetContextToken est renvoyé dans la réponse. Cela peut être utilisé pour afficher un widget Places contextuel.

{
"contents": [{
    "parts": [
      {"text": "Restaurants near Times Square."}
    ]
  }],
  "tools":  { "googleMaps": { "enableWidget": true } }
}

L'outil permet également de transmettre l'emplacement contextuel en tant que toolConfig.

{
  "contents": [{
    "parts": [
      {"text": "Restaurants near here."}
    ]
  }],
  "tools":  { "googleMaps": {} },
  "toolConfig":  {
    "retrievalConfig": {
      "latLng": {
        "latitude": 40.758896,
        "longitude": -73.985130
      }
    }
  }
}

Comprendre la réponse d'ancrage

Lorsqu'une réponse est correctement ancrée dans les données Google Maps, elle inclut un champ groundingMetadata. Ces données structurées sont essentielles pour valider les revendications et créer une expérience de citation riche dans votre application, ainsi que pour répondre aux exigences d'utilisation du service.

{
  "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"
            },
            // repeated ...
          }
        ],
        "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]
          },
          // repeated ...
        ],
        "webSearchQueries": [
          "restaurants near me"
        ],
        "googleMapsWidgetContextToken": "widgetcontent/..."
      }
    }
  ]
}

L'API Gemini renvoie les informations suivantes avec groundingMetadata :

• groundingChunks : tableau d'objets contenant les sources maps (uri, placeId et title).
• groundingSupports : tableau de blocs permettant de relier le texte de réponse du modèle aux sources dans groundingChunks. Chaque bloc associe une plage de texte (définie par startIndex et endIndex) à un ou plusieurs groundingChunkIndices. C'est la clé pour créer des citations insérées.
• googleMapsWidgetContextToken : jeton de texte qui peut être utilisé pour afficher un widget Places contextuel.

Pour obtenir un extrait de code montrant comment afficher des citations intégrées dans du texte, consultez l'exemple dans la documentation sur l'ancrage avec la recherche Google.

Afficher le widget contextuel Google Maps

Pour utiliser le googleMapsWidgetContextToken renvoyé, vous devez charger l'API Maps JavaScript.

Cas d'utilisation

L'ancrage avec Google Maps est compatible avec différents cas d'utilisation basés sur la localisation. Les exemples suivants montrent comment différents paramètres et requêtes peuvent tirer parti de l'ancrage avec Google Maps. Les informations contenues dans les résultats ancrés Google Maps peuvent différer des conditions réelles.

Gérer les questions spécifiques à un lieu

Posez des questions détaillées sur un lieu spécifique pour obtenir des réponses basées sur les avis des utilisateurs Google et d'autres données Maps.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "Is there a cafe near the corner of 1st and Main that has outdoor seating?"

response = client.models.generate_content(
    model='gemini-2.5-flash-lite',
    contents=prompt,
    config=types.GenerateContentConfig(
        # Turn on the Maps tool
        tools=[types.Tool(google_maps=types.GoogleMaps())],

        # Provide the relevant location context (this is in Los Angeles)
        tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
            lat_lng=types.LatLng(
                latitude=34.050481, longitude=-118.248526))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if chunks := grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')
  ```

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function run() {
  const prompt = "Is there a cafe near the corner of 1st and Main that has outdoor seating?";

  const response = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: prompt,
    config: {
      // Turn on the Maps tool
      tools: [{googleMaps: {}}],
      // Provide the relevant location context (this is in Los Angeles)
      toolConfig: {
        retrievalConfig: {
          latLng: {
            latitude: 34.050481,
            longitude: -118.248526
          }
        }
      }
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const chunks = response.candidates[0].groundingMetadata?.groundingChunks;
  if (chunks) {
    console.log('-'.repeat(40));
    console.log("Sources:");
    for (const chunk of chunks) {
      if (chunk.maps) {
        console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
      }
    }
  }
}

run();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Is there a cafe near the corner of 1st and Main that has outdoor seating?"
    }]
  }],
  "tools": [{"googleMaps": {}}],
  "toolConfig": {
    "retrievalConfig": {
      "latLng": {"latitude": 34.050481, "longitude": -118.248526}
    }
  }
}'

Fournir une personnalisation basée sur la localisation

Obtenez des recommandations adaptées aux préférences d'un utilisateur et à une zone géographique spécifique.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "Which family-friendly restaurants near here have the best playground reviews?"

response = client.models.generate_content(
    model='gemini-2.5-flash',
    contents=prompt,
    config=types.GenerateContentConfig(
      tools=[types.Tool(google_maps=types.GoogleMaps())],
      tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
          # Provide the location as context; this is Austin, TX.
          lat_lng=types.LatLng(
              latitude=30.2672, longitude=-97.7431))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if chunks := grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function run() {
  const prompt = "Which family-friendly restaurants near here have the best playground reviews?";

  const response = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: prompt,
    config: {
      tools: [{googleMaps: {}}],
      toolConfig: {
        retrievalConfig: {
          // Provide the location as context; this is Austin, TX.
          latLng: {
            latitude: 30.2672,
            longitude: -97.7431
          }
        }
      }
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const chunks = response.candidates[0].groundingMetadata?.groundingChunks;
  if (chunks) {
    console.log('-'.repeat(40));
    console.log("Sources:");
    for (const chunk of chunks) {
      if (chunk.maps) {
        console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
      }
    }
  }
}

run();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Which family-friendly restaurants near here have the best playground reviews?"
    }],
  }],
  "tools": [{"googleMaps": {}}],
  "toolConfig": {
    "retrievalConfig": {
      "latLng": {"latitude": 30.2672, "longitude": -97.7431}
    }
  }
}'

Aide à la planification d'itinéraires

Générez des plans de plusieurs jours avec des itinéraires et des informations sur différents lieux, parfaits pour les applications de voyage.

Dans cet exemple, googleMapsWidgetContextToken a été demandé en activant le widget dans l'outil Google Maps. Lorsqu'il est activé, le jeton renvoyé peut être utilisé pour afficher un widget Places contextuel à l'aide de <gmp-places-contextual> component de l'API Maps JavaScript.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "Plan a day in San Francisco for me. I want to see the Golden Gate Bridge, visit a museum, and have a nice dinner."

response = client.models.generate_content(
    model='gemini-2.5-flash',
    contents=prompt,
    config=types.GenerateContentConfig(
      tools=[types.Tool(google_maps=types.GoogleMaps(enable_widget=True))],
      tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
          # Provide the location as context, this is in San Francisco.
          lat_lng=types.LatLng(
              latitude=37.78193, longitude=-122.40476))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in grounding.grounding_chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')

  if widget_token := grounding.google_maps_widget_context_token:
    print('-' * 40)
    print(f'<gmp-place-contextual context-token="{widget_token}"></gmp-place-contextual>')

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function run() {
  const prompt = "Plan a day in San Francisco for me. I want to see the Golden Gate Bridge, visit a museum, and have a nice dinner.";

  const response = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: prompt,
    config: {
      tools: [{googleMaps: {enableWidget: true}}],
      toolConfig: {
        retrievalConfig: {
          // Provide the location as context, this is in San Francisco.
          latLng: {
            latitude: 37.78193,
            longitude: -122.40476
          }
        }
      }
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const groundingMetadata = response.candidates[0]?.groundingMetadata;
  if (groundingMetadata) {
    if (groundingMetadata.groundingChunks) {
      console.log('-'.repeat(40));
      console.log("Sources:");
      for (const chunk of groundingMetadata.groundingChunks) {
        if (chunk.maps) {
          console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
        }
      }
    }

    if (groundingMetadata.googleMapsWidgetContextToken) {
      console.log('-'.repeat(40));
      document.body.insertAdjacentHTML('beforeend', `<gmp-place-contextual context-token="${groundingMetadata.googleMapsWidgetContextToken}`"></gmp-place-contextual>`);
    }
  }
}

run();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Plan a day in San Francisco for me. I want to see the Golden Gate Bridge, visit a museum, and have a nice dinner."
    }]
  }],
  "tools": [{"googleMaps": {"enableWidget":"true"}}],
  "toolConfig": {
    "retrievalConfig": {
    "latLng": {"latitude": 37.78193, "longitude": -122.40476}
  }
  }
}'

Une fois le widget affiché, il ressemblera à ce qui suit :

Conditions d'utilisation du service

Cette section décrit les exigences d'utilisation du service pour l'ancrage avec Google Maps.

Informer l'utilisateur sur l'utilisation des sources Google Maps

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

• URI source
• titre
• ID

Lorsque vous présentez des résultats issus 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 soutiennent. Ce contenu généré est également appelé "résultat ancré Google Maps".
• Les sources Google Maps doivent être visibles en une seule interaction utilisateur.

Afficher les sources Google Maps avec des liens Google Maps

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

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

Ces images montrent les exigences minimales pour afficher les sources et les liens Google Maps.

Vous pouvez réduire l'affichage des sources.

Facultatif : Améliorez l'aperçu du lien avec du contenu supplémentaire, par exemple :

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

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

Consignes relatives à 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 typographie de Google Maps.
  • Ne pas envelopper Google Maps sur plusieurs lignes.
  • Ne localisez pas Google Maps dans une autre langue.
  • Empêchez les navigateurs de traduire Google Maps en utilisant l'attribut HTML translate="no".
• Mettez en forme le texte Google Maps comme décrit dans le tableau suivant :

Exemple d'élément CSS

Le code CSS suivant affiche 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;
}

Jeton de contexte, ID de lieu et ID d'avis

Les données Google Maps incluent le jeton de contexte, l'ID de lieu et l'ID d'avis. Vous pouvez mettre en cache, stocker et exporter les données de réponse suivantes :

• googleMapsWidgetContextToken
• placeId
• reviewId

Les restrictions de mise en cache dans les conditions d'utilisation de l'ancrage avec Google Maps ne s'appliquent pas.

Activité et territoire 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 indiquées dans les Conditions d'utilisation, 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. Les territoires actuellement interdits sont les suivants :

• Chine
• Crimée
• Cuba
• République populaire de Donetsk
• Iran
• République populaire de Lougansk
• Corée du Nord
• Syrie
• Viêt Nam

Cette liste peut être mise à jour de temps en temps.

Bonnes pratiques

• Fournissez la position de l'utilisateur : pour obtenir les réponses les plus pertinentes et personnalisées, incluez toujours user_location (latitude et longitude) dans la configuration googleMapsGrounding lorsque la position de l'utilisateur est connue.
• 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 de l'API Gemini 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 le guide du développeur Google.
• Informez les utilisateurs finaux : indiquez clairement à vos utilisateurs finaux que les données Google Maps sont utilisées pour répondre à leurs requêtes, en particulier lorsque l'outil est activé.
• Surveillez la latence : pour les applications conversationnelles, assurez-vous que la latence P95 pour les réponses ancrées reste dans les seuils acceptables afin de maintenir une expérience utilisateur fluide.
• Désactivez l'ancrage lorsque vous n'en avez pas besoin : l'ancrage avec Google Maps est désactivé par défaut. Ne l'activez ("tools": [{"googleMaps": {}}]) que lorsqu'une requête présente un contexte géographique clair, afin d'optimiser les performances et les coûts.

Limites

• Couverture géographique : l'ancrage avec Google Maps est actuellement disponible dans le monde entier.
• Modèles compatibles : seuls certains modèles Gemini sont compatibles avec l'ancrage avec Google Maps : Gemini 2.5 Flash-Lite, Gemini 2.5 Pro, Gemini 2.5 Flash et Gemini 2.0 Flash (mais pas Gemini 2.0 Flash-Lite).
• Entrées/Sorties multimodales : l'ancrage avec Google Maps n'accepte actuellement pas les entrées ni les sorties multimodales au-delà du texte et des widgets de carte contextuels.
• État par défaut : l'outil d'ancrage avec Google Maps est désactivé par défaut. Vous devez l'activer explicitement dans vos requêtes API.

Tarifs et limites de débit

La tarification de l'ancrage avec Google Maps est basée sur les requêtes. Le tarif actuel est de 25$pour 1 000 requêtes ancrées. Une requête n'est comptabilisée dans le quota que lorsqu'une requête renvoie au moins un résultat ancré Google Maps (c'est-à-dire des résultats contenant 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 par rapport à la limite de fréquence.

Pour en savoir plus sur les tarifs, consultez la page des tarifs de l'API Gemini.

Modèles compatibles

Vous trouverez leurs capacités sur la page Présentation des modèles.

Étape suivante

• Essayez l'ancrage avec la recherche Google dans le livre de recettes de l'API Gemini.
• Découvrez d'autres outils disponibles, comme les appels de fonction.
• Pour en savoir plus sur les bonnes pratiques d'IA responsable et les filtres de sécurité de l'API Gemini, consultez le guide sur les paramètres de sécurité.