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 provenant de Google Maps. Le serveur MCP fournit des outils qui permettent aux LLM d'accéder aux fonctionnalités liées aux lieux, à la météo et aux itinéraires. 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 générés par IA, ainsi que des ID de lieux, 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, ainsi que 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 : demander des informations sur la météo et obtenir 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 obtenez 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'informations sur le trafic en temps réel ni d'informations de navigation.

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 pour le contexte, la réponse qu'il génère finalement 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.

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

Facturation et quotas

Comment êtes-vous facturé ?

Avec le modèle de paiement à l'usage de Google Maps Platform, l'utilisation de Maps Grounding Lite est calculée pour chaque requête, où chaque requête représente un événement facturable. L'utilisation est suivie pour chaque SKU de produit. Votre facture comporte une ligne pour chaque SKU, en plus du montant total facturé. Pour en savoir plus, consultez Présentation des rapports.

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

Maps Grounding Lite est également proposé dans les forfaits Essentials et Pro S'abonner pour faire des économies.

Quotas

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

Rechercher des lieux : 300 requêtes par minute et par projet.
Rechercher la météo : 300 requêtes par minute et par projet.
Calculer des itinéraires : 300 requêtes par minute et par projet.

Règles et conditions d'utilisation

Maps Grounding Lite est soumis aux Conditions d'utilisation de Google Maps Platform, y compris les Conditions spécifiques du service pour ce service. Cette section décrit les exigences supplémentaires concernant l'utilisation du service Maps Grounding Lite, y compris les LLM compatibles et les exigences relatives à 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é ni 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 Maps Grounding Lite avec des modèles qui utilisent les données saisies dans le modèle pour l'entraînement ou l'amélioration de modèles. Vous êtes responsable de l'utilisation que vous faites du modèle et devez vous assurer qu'elle respecte pleinement les restrictions concernant 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 des 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 soutiennent. Ce contenu généré est également appelé sortie ancrée.
Les sources Google Maps doivent être visibles en une seule interaction utilisateur.

Sources de l'outil Rechercher des lieux

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

place (nom de ressource)
id
location
googleMapsLinks

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

Attribuez chaque source à Google Maps en suivant les consignes concernant l'attribution de texte Maps Grounding Lite.
Associez la source à l'aide de places.googleMapsLinks.placeUrl à partir 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 qu'une clé API ou 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.

Activez le service Maps Grounding Lite dans 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 Maps Grounding Lite.
Activez la facturation pour le projet dans la console Google Cloud.
Activez Maps Grounding Lite 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 sur la clé.

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

Créez ou configurez une clé API en suivant les étapes de 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 à l'aide d'OAuth

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

Pour vous authentifier à l'aide d'OAuth :

Dans la console Google Cloud, sélectionnez le projet que vous souhaitez utiliser pour Maps Grounding Lite.
Dans le menu API et services, sélectionnez Identifiants.
Dans le menu du haut, 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 et 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 informations supplémentaires qui s'appliquent à votre type d'application. Par exemple, si vous créez une application Web, ajoutez des URI autorisés pour les requêtes de navigateur et de serveur.
Une fois votre client créé, enregistrez l'ID client et le code secret.
Lorsque vous configurez votre hôte ou votre application serveur MCP pour accéder à Maps Grounding Lite, transmettez votre ID client et votre secret OAuth. Vous devez également demander le champ d'application 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 accéder au serveur MCP Maps Grounding Lite

Une fois que vous disposez d'un projet Google Cloud avec le service Maps Grounding Lite API activé et des identifiants valides, tels qu'une clé API ou un ID et un secret de client OAuth, vous pouvez configurer les LLM pour accéder 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 MCP dans une application d'IA.

Configurer Maps Grounding Lite 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 Gemini CLI 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, une confirmation indiquant que le serveur a été ajouté à vos paramètres utilisateur devrait s'afficher.

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

> /mcp list

Configured MCP servers:

maps-grounding-lite-mcp - Ready (3 tools)
Tools:
-   compute_routes
-   lookup_weather
-   search_places

Commencez à poser des questions sur Maps avec la CLI. Par exemple, essayez "Recommande-moi des restaurants à Mountain View", 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

É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.

# ./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 d'avoir 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 une variable d'environnement :
Définissez votre clé API Google Maps comme 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'UI :
- Sélectionnez le travel_planner_agent.
- Voici quelques exemples de requêtes :
  - "Je serai à San Francisco demain. Quel temps fait-il ?"
  - "Trouve des cafés près du Golden Gate Park."
  - "Itinéraire de GooglePlex à SFO."

Java

Définissez un agent qui initialise McpToolset en Java. Remplacez YOUR_GOOGLE_MAPS_API_KEY_HERE par la clé API réelle 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"
            }
        })
    ],
});

Envoyer des commentaires

Pour partager vos commentaires sur Maps Grounding Lite, utilisez les formulaires suivants :