Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Maps Grounding Lite

Google Maps Platform Grounding Lite est un service compatible avec le protocole MCP (Model Context Protocol) qui permet d'ancrer facilement vos applications d'IA avec des données géospatiales fiables de Google Maps. Le serveur MCP fournit des outils qui permettent aux LLM d'accéder aux fonctionnalités pour les lieux, la météo et les itinéraires, et de résoudre les noms de lieux et les URL Google Maps en ID de lieu. Vous pouvez essayer Maps Grounding Lite en l'activant dans n'importe quel outil compatible avec les serveurs MCP.

Outils

Maps Grounding Lite fournit des outils qui permettent aux LLM d'accéder aux fonctionnalités Google Maps suivantes :

Rechercher des lieux : demandez des informations sur des lieux et obtenez des résumés de données de lieux générés par l'IA, ainsi que des ID de lieu, des coordonnées de latitude et de longitude, et des liens Google Maps pour chacun des lieux inclus dans le résumé. Vous pouvez utiliser les ID de lieu et les coordonnées de latitude et de longitude renvoyés avec d'autres API Google Maps Platform pour afficher des lieux sur une carte.
Rechercher la météo : demandez des informations sur la météo et obtenez les conditions actuelles, les prévisions horaires et les prévisions quotidiennes.
Calculer des itinéraires : demandez des informations sur les itinéraires en voiture ou à pied entre deux lieux, et renvoyez des informations sur la distance et la durée de l'itinéraire.

Remarque : Maps Grounding Lite ne fournit pas d'itinéraires détaillés, d'itinéraires, d'informations sur le trafic en temps réel ni d'informations de navigation.
Résoudre les noms et Résoudre les URL Maps : résolvez les noms de lieux, les adresses et les URL Google Maps en ID de lieu. Pour en savoir plus, consultez API Resolution.

L'activation du serveur MCP Maps Grounding Lite permet aux LLM d'appeler les nouveaux outils exposés par le serveur pour renvoyer des informations d'ancrage supplémentaires pour les types de données listés ci-dessus. Bien que le LLM puisse utiliser ces informations supplémentaires comme contexte, la réponse qu'il génère peut ne pas inclure les informations exactes renvoyées par le serveur MCP. Vous devez vérifier l'exactitude de la réponse générée.

API Resolution

Maps Grounding Lite fournit l'API Resolution, qui vous permet de résoudre du texte et des URL de lieu au format libre en identifiants de lieu Google Maps structurés. L'API Resolution est disponible sous forme de méthodes REST et d'outils sur le serveur MCP Maps Grounding Lite :

Résoudre les noms (REST, MCP) : résolvez un lot de noms ou d'adresses de lieux en entités de lieux spécifiques sur Google Maps. Cela est utile pour ancrer les requêtes utilisateur non structurées dans des ID de lieu stables.
Résoudre les URL Maps (REST, MCP) : résolvez un lot d'URL Google Maps vers des entités de lieu spécifiques. Les formats acceptés incluent les URL de lieux standards et les URL raccourcies.

Vous pouvez utiliser les ID de lieu renvoyés avec d'autres API Google Maps Platform. Chaque réponse inclut également un lien qui enregistre les lieux résolus sous forme de liste dans Google Maps.

Pour en savoir plus, consultez API Maps Tools Resolution.

Essayer l'application exemple Grounding Lite Maps (ouvrir dans un nouvel onglet)

Facturation et quotas

Comment êtes-vous facturé ?

Avec le modèle de tarification à l'usage de Google Maps Platform, l'utilisation de l'ancrage Maps Lite est calculée pour chaque requête, où chaque requête représente un événement de facturation. L'utilisation est suivie pour chaque SKU de produit. Votre facture affiche une ligne pour chaque SKU en plus du montant total de vos frais. Pour en savoir plus, consultez la présentation des rapports.

Pour en savoir plus sur les tarifs, consultez la grille tarifaire principale et la grille tarifaire pour l'Inde.

Les requêtes envoyées à l'API Resolution (ResolveNames et ResolveMapsUrls) sont facturées sans frais sous le SKU API Places Text Search Essentials (IDs Only).

Maps Grounding Lite est également proposé via les forfaits Essentials et Pro S'abonner pour économiser.

Quotas

Les quotas suivants s'appliquent aux outils et aux API fournis par Maps Grounding Lite :

Rechercher des lieux : 300 requêtes par minute et par projet.
Recherche de météo : 300 requêtes par minute et par projet.
Calculer des itinéraires : 300 requêtes par minute et par projet.
Résoudre les noms : 600 requêtes par minute et par projet.
Résoudre les URL Maps : 600 requêtes par minute et par projet.

Chaque requête API Resolution compte comme une seule requête, quel que soit le nombre d'éléments qu'elle contient.

Règles et conditions d'utilisation

Maps Grounding Lite est soumis aux Conditions d'utilisation de Google Maps Platform, y compris aux conditions spécifiques de ce service. Cette section décrit les exigences supplémentaires d'utilisation du service pour Maps Grounding Lite, y compris les LLM compatibles et les exigences concernant l'attribution de la source.

Exigences concernant les LLM compatibles

Vous ne pouvez utiliser Maps Grounding Lite qu'avec un LLM conforme aux conditions d'utilisation de Google Maps Platform.

Par exemple, vous devez vous assurer que le contenu Google Maps n'est pas mis en cache, stocké ou utilisé pour améliorer le LLM que vous choisissez d'utiliser. Avant d'utiliser Maps Grounding Lite, vous devez consulter les conditions d'utilisation de tout modèle que vous prévoyez d'utiliser avec Maps Grounding Lite. Vous ne devez pas utiliser Grounding Lite avec des modèles qui utilisent les données d'entrée du modèle pour l'entraînement ou l'amélioration du modèle. Il vous incombe de vous assurer que votre utilisation du modèle respecte pleinement les restrictions sur le contenu Google Maps dans les conditions d'utilisation de Google Maps Platform, y compris les conditions spécifiques au service.

Exigences d'attribution pour les sources Google Maps

Chaque réponse d'outil de Maps Grounding Lite inclut des sources. Lorsque vous présentez des résultats qui utilisent les outils fournis par Maps Grounding Lite, vous devez inclure les sources Google Maps associées de manière à respecter les exigences suivantes :

Les sources Google Maps doivent suivre immédiatement le contenu généré qu'elles appuient. Ce contenu généré est également appelé résultat ancré.
Les sources Google Maps doivent être visibles en une seule interaction de l'utilisateur.

Sources de l'outil "Rechercher des lieux"

Le champ places de l'outil search_places fournit des sources compatibles avec summary. Pour places, les métadonnées suivantes sont renvoyées :

place (nom de la ressource)
id
location
googleMapsLinks

Pour chaque lieu, vous devez générer un aperçu de lien qui répond aux exigences suivantes :

Attribuez chaque source à Google Maps, en suivant les consignes d'attribution de texte pour Grounding Lite Maps.
Associez-le à la source à l'aide de l'places.googleMapsLinks.placeUrl de la réponse.

Configurer les LLM pour qu'ils utilisent le serveur MCP

Pour utiliser Maps Grounding Lite, vous devez d'abord disposer d'un projet Google Cloud avec le service d'API Maps Grounding Lite activé, ainsi que d'une clé API ou d'un ID client OAuth. Vous pouvez ensuite configurer les LLM pour qu'ils accèdent au serveur MCP. Le serveur MCP Grounding Lite utilise le transport HTTP en flux continu.

Activez le service Maps Grounding Lite sur votre projet Google Cloud.

Pour activer l'API dans votre projet :

Dans la console Google Cloud, sélectionnez le projet que vous souhaitez utiliser pour Grounding Lite Maps.
Activez la facturation pour le projet dans la console Google Cloud.
Activez Grounding Lite Maps dans la bibliothèque d'API de la console Google Cloud.

S'authentifier à l'aide d'une clé API

Vous pouvez utiliser une clé API existante avec Maps Grounding Lite ou en créer une, à condition d'activer le service d'API Maps Grounding Lite sur le projet Google Cloud et la clé.

Pour vous authentifier à l'aide d'une clé API :

Créez ou configurez une clé API en suivant les étapes décrites dans Premiers pas avec Google Maps Platform.
Transmettez la clé au serveur MCP à l'aide de l'en-tête X-Goog-Api-Key. Vous devez le spécifier en tant qu'en-tête HTTP personnalisé dans la configuration de l'outil MCP du LLM.

S'authentifier avec OAuth

Vous pouvez vous authentifier à l'aide d'OAuth en créant des identifiants OAuth et en les transmettant à l'hôte MCP ou à l'application serveur MCP.

Pour vous authentifier à l'aide d'OAuth :

Dans la console Google Cloud, choisissez le projet que vous souhaitez utiliser pour Grounding Lite Maps.
Dans le menu API et services, sélectionnez Identifiants.
Dans le menu supérieur, sélectionnez Créer des identifiants > ID client OAuth.
Si l'écran de consentement n'est pas configuré pour le projet, cliquez sur Configurer l'écran de consentement, puis suivez les instructions à l'écran.
Dans la section Métriques, cliquez sur Créer un client OAuth.
Sur l'écran Créer un ID client OAuth, sélectionnez un type d'application et saisissez un nom pour l'ID client.
Spécifiez les détails supplémentaires pertinents pour votre type d'application. Par exemple, si vous créez une application Web, ajoutez des URI autorisés pour les requêtes du navigateur et du serveur.
Une fois votre client créé, enregistrez l'ID client et le code secret.
Lorsque vous configurez votre application hôte MCP ou serveur MCP pour accéder à Maps Grounding Lite, transmettez votre ID client et votre code secret OAuth. Vous devez également demander le niveau d'accès suivant : https://www.googleapis.com/auth/maps-platform.mapstools.

Pour en savoir plus, consultez Utiliser OAuth 2.0 pour accéder aux API Google.

Configurer les LLM pour qu'ils accèdent au serveur MCP Maps Grounding Lite

Une fois que vous disposez d'un projet Google Cloud avec le service API Maps Grounding Lite activé et d'identifiants valides, tels qu'une clé API ou un ID client et un code secret OAuth, vous pouvez configurer les LLM pour qu'ils accèdent au serveur MCP en suivant la documentation de configuration MCP correspondante et en utilisant l'URL du serveur MCP Maps Grounding Lite : https://mapstools.googleapis.com/mcp.

Pour en savoir plus, consultez Configurer le MCP dans une application d'IA.

Configurer Grounding Lite Maps avec Gemini CLI

Cette section fournit un exemple de configuration du serveur MCP Maps Grounding Lite à l'aide de la CLI Gemini. Pour en savoir plus, consultez Serveurs MCP avec Gemini CLI.

Une fois la CLI Gemini installée, vous pouvez utiliser la commande add pour configurer le serveur MCP Maps Grounding Lite :
```
gemini mcp add -s user -t http -H 'X-Goog-Api-Key: API_KEY' maps-grounding-lite-mcp https://mapstools.googleapis.com/mcp
```
Si la configuration a réussi, un message de confirmation s'affiche pour indiquer que le serveur a été ajouté à vos paramètres utilisateur.

Pour vérifier que le serveur fonctionne correctement, exécutez la commande /mcp list :

> /mcp list

Configured MCP servers:

maps-grounding-lite-mcp - Ready (5 tools)
Tools:
-   compute_routes
-   lookup_weather
-   resolve_maps_urls
-   resolve_names
-   search_places

Commencez à poser des questions sur Maps avec la CLI. Par exemple, essayez "Recommande-moi des restaurants à Mountain View", ce qui devrait appeler l'outil search_places en votre nom.

Configurer Grounding Lite avec Agent Development Kit (ADK)

Cette section fournit des exemples montrant comment configurer le serveur MCP Grounding Lite à l'aide de l'Agent Development Kit (ADK) et de Python, Java ou TypeScript.

Python

Vous trouverez une implémentation complète de cet exemple sur GitHub dans le dépôt adk-samples.

Étape 1 : Définissez votre agent avec `McpToolset` pour Google Maps Grounding Lite

Modifiez votre fichier agent.py. Remplacez YOUR_GOOGLE_MAPS_API_KEY par votre clé API réelle.

# ./adk_agent_samples/mcp_agent/agent.py
import os
from google.adk.agents.llm_agent import Agent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

# Retrieve the API key from an environment variable or directly insert it.
GOOGLE_MAPS_API_KEY = os.getenv("GOOGLE_MAPS_API_KEY")
if not GOOGLE_MAPS_API_KEY:
    GOOGLE_MAPS_API_KEY = "YOUR_GOOGLE_MAPS_API_KEY_HERE"

if GOOGLE_MAPS_API_KEY == "YOUR_GOOGLE_MAPS_API_KEY_HERE":
    print("WARNING: GOOGLE_MAPS_API_KEY is not set.")

root_agent = Agent(
    model='gemini-flash-latest',
    name='travel_planner_agent',
    description='A helpful assistant for planning travel routes.',
    tools=[
        McpToolset(
            connection_params=StreamableHTTPConnectionParams(
                url="https://mapstools.googleapis.com/mcp",
                headers={
                    "X-Goog-Api-Key": GOOGLE_MAPS_API_KEY,
                    "Content-Type": "application/json",
                    "Accept": "application/json, text/event-stream"
                }
            )
        )
    ]
)

Étape 2 : Assurez-vous que `init.py` existe

Assurez-vous de disposer d'un fichier __init__.py dans le même répertoire que votre fichier agent.py :

from . import agent

Étape 3 : Exécuter `adk web` et interagir

Définir la variable d'environnement :
Définissez votre clé API Google Maps en tant que variable d'environnement dans votre terminal :
```
export GOOGLE_MAPS_API_KEY="YOUR_ACTUAL_GOOGLE_MAPS_API_KEY"
        
```
Exécutez adk web :
Exécutez la commande suivante pour démarrer l'interface Web ADK :
```
adk web
        
```
Interagir dans l'interface utilisateur :
- Sélectionnez le travel_planner_agent.
- Quelques idées de prompts :
  - "Je serai à San Francisco demain. Quel temps fait-il ?"
  - "Trouve des cafés près du parc du Golden Gate."
  - "Get directions from GooglePlex to SFO."

Java

Définissez un agent qui initialise McpToolset en Java. Remplacez YOUR_GOOGLE_MAPS_API_KEY_HERE par la clé API que vous avez obtenue si vous n'utilisez pas de variable d'environnement.

package agents;

import com.google.adk.agents.LlmAgent;
import com.google.adk.runner.InMemoryRunner;
import com.google.adk.sessions.SessionKey;
import com.google.adk.tools.mcp.McpToolset;
import com.google.adk.tools.mcp.StreamableHttpServerParameters;
import com.google.genai.types.Content;
import com.google.genai.types.Part;
import java.util.HashMap;
import java.util.Map;

public class MapsAgentCreator {
    public static void main(String[] args) {
        String googleMapsApiKey = System.getenv("GOOGLE_MAPS_API_KEY");
        if (googleMapsApiKey == null || googleMapsApiKey.trim().isEmpty()) {
            googleMapsApiKey = "YOUR_GOOGLE_MAPS_API_KEY_HERE";
            if ("YOUR_GOOGLE_MAPS_API_KEY_HERE".equals(googleMapsApiKey)) {
                System.out.println("WARNING: GOOGLE_MAPS_API_KEY is not set.");
            }
        }

        Map<String, String> headers = new HashMap<>();
        headers.put("X-Goog-Api-Key", googleMapsApiKey);
        headers.put("Content-Type", "application/json");
        headers.put("Accept", "application/json, text/event-stream");

        StreamableHttpServerParameters serverParams =
                StreamableHttpServerParameters.builder("https://mapstools.googleapis.com/mcp")
                        .headers(headers)
                        .build();

        try (McpToolset toolset = new McpToolset(serverParams)) {
            LlmAgent agent = LlmAgent.builder()
                    .model("gemini-flash-latest")
                    .name("travel_planner_agent")
                    .description("A helpful assistant for planning travel routes.")
                    .tools(toolset)
                    .build();

            System.out.println("Agent created: " + agent.name());

            InMemoryRunner runner = new InMemoryRunner(agent);
            String userId = "maps-user-" + System.currentTimeMillis();
            String sessionId = "maps-session-" + System.currentTimeMillis();
            String promptText =
                    "Please give me directions to the nearest pharmacy to Madison Square Garden.";

            SessionKey sessionKey = runner.sessionService()
                    .createSession(runner.appName(), userId, null, sessionId)
                    .blockingGet()
                    .sessionKey();
            System.out.println("Session created: " + sessionId + " for user: " + userId);

            Content promptContent = Content.fromParts(Part.fromText(promptText));
            System.out.println("\nSending prompt: \"" + promptText + "\" to agent...\n");

            runner.runAsync(sessionKey, promptContent)
                    .blockingForEach(event -> {
                        System.out.println("Event received: " + event.toJson());
                    });
        } catch (Exception e) {
            System.err.println("An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

TypeScript

Définissez un agent qui initialise MCPToolset en TypeScript :

import 'dotenv/config';
import {LlmAgent, MCPToolset} from "@google/adk";

const googleMapsApiKey = process.env.GOOGLE_MAPS_API_KEY;
if (!googleMapsApiKey) {
    console.warn("WARNING: GOOGLE_MAPS_API_KEY is not set.");
    throw new Error(
        'GOOGLE_MAPS_API_KEY is not provided, please run "export GOOGLE_MAPS_API_KEY=YOUR_ACTUAL_KEY" to add that.'
    );
}

export const rootAgent = new LlmAgent({
    model: "gemini-flash-latest",
    name: "travel_planner_agent",
    description: "A helpful assistant for planning travel.",
    tools: [
        new MCPToolset({
            type: "SseConnectionParams",
            url: "https://mapstools.googleapis.com/mcp",
            headers: {
                "X-Goog-Api-Key": googleMapsApiKey,
                "Content-Type": "application/json",
                "Accept": "application/json, text/event-stream"
            }
        })
    ],
});

Partager des commentaires

Pour nous faire part de vos commentaires sur Maps Grounding Lite, utilisez les formulaires suivants :