Grounding z użyciem Map Google

Grounding z użyciem Google Maps łączy model Gemini z danymi geoprzestrzennymi z Google Maps, dzięki czemu możesz tworzyć w aplikacjach funkcje uwzględniające lokalizację.

Grounding z użyciem Google Maps ma te zalety:

  • Zwiększenie dokładności faktograficznej: zmniejsz halucynacje modelu, opierając odpowiedzi na bazie danych Google zawierającej ponad 250 milionów rzeczywistych miejsc i firm.
  • Dostęp do informacji w czasie rzeczywistym: odpowiadaj na pytania, korzystając z danych na żywo, takich jak aktualne godziny otwarcia i stan stacji ładowania pojazdów elektrycznych w czasie rzeczywistym.
  • Zapewnianie kontekstu wizualnego: zwiększ zaufanie użytkowników, integrując interaktywne widżety map, zdjęcia i Street View bezpośrednio obok informacji o lokalizacji podawanych przez model.

Obsługiwane modele

  • gemini-3.1-pro-preview
  • gemini-3.6-flash (i starszy gemini-3.5-flash)
  • gemini-3.5-flash-lite (i starszy gemini-3.1-flash-lite)

Modele Gemini 2.5 ogólnego użytku obsługują tę funkcję, ale wszystkie są już wycofane.

Obsługiwane języki

Zobacz obsługiwane języki w przypadku modeli Gemini.

Grounding modelu z użyciem Google Maps

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dotyczące konkretnego dostawcy.

Podczas tworzenia instancji GenerativeModel podaj GoogleMaps jako tool, którego model może używać do generowania odpowiedzi.

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

Dowiedz się, jak wybrać model odpowiednią do Twojego przypadku użycia i aplikacji.

Sprawdzone metody i wskazówki dotyczące poprawy wyników

W tej sekcji opisujemy ogólne sprawdzone metody korzystania z groundingu z użyciem Google Maps, a także sposób wykorzystania właściwości miejsca do poprawy wyników.

Ogólne sprawdzone metody

  • Udostępniaj narzędzie tylko wtedy, gdy jest to potrzebne: aby zoptymalizować wydajność i koszty, udostępniaj modelowi dostęp do narzędzia Grounding z użyciem Google Maps tylko wtedy, gdy przypadek użycia ma wyraźny kontekst geograficzny.

  • Podawaj lokalizację użytkownika: aby uzyskać najbardziej trafne i spersonalizowane odpowiedzi (i gdy znana jest lokalizacja użytkownika), uwzględnij lokalizację użytkownika (za pomocą szerokości i długości geograficznej w polu latLng) w konfiguracji narzędzia Grounding z użyciem Google Maps.

  • Informuj użytkowników: wyraźnie informuj użytkowników, że używane są dane Google Maps do odpowiadania na ich pytania. Udostępnianie użytkownikom źródeł z Google Maps jest wymaganiem dotyczącym korzystania z usługi dla narzędzia Grounding z użyciem Google Maps.

  • (Tylko pakiet SDK na potrzeby internetu) Renderuj widżet kontekstowy Google Maps: widżet kontekstowy jest renderowany za pomocą tokena kontekstu googleMapsWidgetContextToken, który jest zwracany w odpowiedzi Gemini API i może służyć do renderowania treści wizualnych z Google Maps. Więcej informacji o widżecie kontekstowym znajdziesz w dokumentacjiGoogle Maps w artykule Widżet Grounding z użyciemGoogle Maps.

Używanie właściwości miejsca w promptach

W tej sekcji znajdziesz listę właściwości miejsca, które służą do opisywania lokalizacji i są używane przez narzędzie Grounding z użyciem Google Maps do generowania odpowiedzi. Te właściwości służą do określania typów pytań, na które może odpowiadać narzędzie Grounding z użyciem Google Maps.

Przykładowe właściwości miejsca

Ta lista zawiera alfabetyczny wykaz przykładowych właściwości miejsc, których model może używać do generowania odpowiedzi.

  • Adres
  • Odbiór na zewnątrz
  • Karta debetowa
  • Odległość
  • Bezpłatny parking
  • Muzyka na żywo
  • Menu dla dzieci
  • Godziny otwarcia
  • Opcje płatności (np. gotówka lub karta kredytowa)
  • Odpowiedź dotycząca miejsca
  • Przyjazne dla zwierząt
  • Oferuje piwo
  • Oferuje dania wegetariańskie
  • Dostępne dla niepełnosprawnych
  • Wi-Fi

Odpowiedzi dotyczące miejsc to odpowiedzi z narzędzia Grounding z użyciem Google Maps oparte na informacjach pochodzących z opinii użytkowników.

Przykładowe prompty, które używają właściwości miejsca

W tych przykładach używamy właściwości miejsca w promptach dotyczących różnych typów miejsc. Narzędzie Grounding z użyciem Google Maps używa tych właściwości, aby zrozumieć Twoje intencje, a następnie podaje trafne odpowiedzi na podstawie danych powiązanych z miejscami w Google Maps.

  • Planowanie rodzinnego obiadu: sprawdź, czy restauracja jest odpowiednia dla rodziny i czy oferuje wygodną usługę.

    • Przykładowy prompt: Czy restauracja „The Italian Place” jest odpowiednia dla dzieci i czy oferuje jedzenie na wynos? Jaka jest jej ocena?

  • Sprawdzanie dostępności dla znajomego: sprawdź, czy lokalizacja spełnia określone potrzeby w zakresie dostępności.

    • Przykładowy prompt: Potrzebuję restauracji z wejściem dostępnym dla wózków inwalidzkich.

  • Znajdowanie miejsca na przekąskę późnym wieczorem: znajdź otwarty lokal, który serwuje określony posiłek o określonej porze.

    • Przykładowy prompt: Czy "Burger Joint" jest teraz otwarty? Czy serwują kolację?_ Jakie są godziny otwarcia w piątek?

  • Spotkanie z klientem na kawę: oceń, czy kawiarnia jest odpowiednia na spotkanie biznesowe na podstawie udogodnień, oferty i opcji płatności.

    • Przykładowy prompt: Czy w „Cafe Central” jest Wi-Fi? Czy serwują kawę?_ Jaki jest poziom cen i czy akceptują karty kredytowe?

Pamiętaj, że informacje w Google Maps wynikach opartych na Mapach Google mogą się różnić od rzeczywistych warunków na drodze.

Jak działa Grounding z użyciem Google Maps

Gdy udostępnisz modelowi narzędzie GoogleMaps, model automatycznie obsłuży cały proces wyszukiwania, przetwarzania i cytowania informacji.

Oto proces modelu:

  1. Otrzymuje prompt: Twoja aplikacja wysyła prompt do modelu Gemini z włączonym narzędziem GoogleMaps.

  2. Analizuje prompt: model analizuje prompt i sprawdza, czy Google Maps może poprawić jego odpowiedź, np. czy prompt zawiera kontekst geograficzny (np. „kawiarnie w pobliżu”, „muzea w San Francisco”).

  3. Wywołuje narzędzie: model, rozpoznając intencje geograficzne, wywołuje narzędzie Grounding z użyciem Google Maps.

  4. Wysyła zapytania do Google Maps: usługa Grounding z użyciem Google Maps wysyła zapytania do Google Maps, aby uzyskać odpowiednie informacje (np. miejsca, opinie, zdjęcia, adresy, godziny otwarcia).

    Aby uzyskać bardziej trafne i spersonalizowane Google Maps wyniki, możesz opcjonalnie uwzględnić szerokość i długość geograficzną w konfiguracji narzędzia (lub nawet bezpośrednio w prompcie). Narzędzie to służy do wyszukiwania tekstowego i działa podobnie jak wyszukiwanie w Google Maps. Zapytania lokalne („w pobliżu”) będą używać współrzędnych, a zapytania konkretne lub nielokalne raczej nie będą uwzględniać wyraźnej lokalizacji.

  5. Przetwarza wynikiGoogle Maps: model przetwarza wyniki Google Maps i formułuje odpowiedź na pierwotny prompt.

  6. Zwraca Google Maps wynik oparty na: model zwraca ostateczną, przyjazną dla użytkownika odpowiedź, która jest oparta na Google Maps wynikach. Ta odpowiedź zawiera:

    • Tekstową odpowiedź modelu.
    • Obiekt groundingMetadata z wynikami i źródłami.Google Maps
    • (Tylko pakiet SDK na potrzeby internetu) Opcjonalnie token googleMapsWidgetContextToken, który umożliwia renderowanie w aplikacji widżetu kontekstowego Google Maps do interakcji wizualnych. Więcej informacji o widżecie kontekstowym znajdziesz w dokumentacji Google Maps w artykule Widżet Grounding z użyciem Google Maps widget.

Pamiętaj, że udostępnienie Google Maps jako narzędzia dla modelu nie wymaga aby model zawsze używał narzędzia Google Maps do generowania odpowiedzi. W takich przypadkach odpowiedź nie będzie zawierać obiektu groundingMetadata, a zatem nie będzie wynikiem opartym na Google Maps Mapach Google.

Interpretowanie wyniku opartego na Mapach Google

Jeśli model opiera swoją odpowiedź na Google Maps wynikach, odpowiedź zawiera obiekt groundingMetadata, który zawiera dane strukturalne niezbędne do weryfikowania informacji i tworzenia w aplikacji bogatego źródła.

Obiekt groundingMetadata w Google Maps wyniku opartego na Mapach Google zawiera te informacje:

  • groundingChunks: tablica obiektów zawierających źródła maps (uri, placeId i title).
  • groundingSupports: tablica fragmentów, które łączą tekst odpowiedzi modelu text ze źródłami w groundingChunks. Każdy fragment łączy segment tekstu (zdefiniowany przez startIndex i endIndex) z co najmniej 1 elementem groundingChunkIndices. To pole pomaga tworzyć linki do źródeł w tekście. Więcej informacji o tym, jak spełnić wymagania dotyczące korzystania z usługi, znajdziesz w dalszej części tej strony.
  • (Tylko pakiet SDK na potrzeby internetu) googleMapsWidgetContextToken: token tekstowy, którego można użyć do renderowania widżetu kontekstowego Miejsca. To pole jest zwracane tylko wtedy, gdy używasz pakietu SDK na potrzeby internetu i jeśli parametr enableWidget ma wartość true.

Oto przykładowa odpowiedź, która zawiera obiekt 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/..."
      }
    }
  ]
}

Wymagania dotyczące korzystania z usługi

W tej sekcji opisujemy wymagania dotyczące korzystania z usługi Grounding z użyciem Google Maps w przypadku wybranego przez Ciebie Gemini API dostawcy: Gemini Developer API lub Agent Platform Gemini API (formerly Vertex AI) (patrz Warunki korzystania z usługi sekcja w Szczegółowych warunkach korzystania z usługi).

Informowanie użytkowników o źródłach Google Maps

W przypadku każdego Google Maps wyniku opartego na Mapach Google otrzymasz źródła w groundingChunks, które obsługują każdą odpowiedź. Zwracane są też te metadane:

  • Identyfikator URI danych źródłowych
  • Tytuł
  • Identyfikator

Gdy w aplikacji prezentujesz wyniki z narzędzia Grounding z użyciem Google Maps, musisz określić powiązane źródła z Google Maps i poinformować użytkowników o tych kwestiach:

  • Źródła Google Maps muszą znajdować się bezpośrednio po wygenerowanej treści którą obsługują. Ta wygenerowana treść jest też nazywana Google Maps wynikiem opartym na Mapach Google.

  • Źródła Google Maps muszą być widoczne w ramach jednej interakcji użytkownika.

Oto jak uzyskać wartości do wyświetlania źródeł z Google Maps wyniku opartego na Mapach Google:

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

W przypadku każdego źródła w groundingChunks należy wygenerować podgląd linku zgodnie z tymi wymaganiami:

Prompt z odpowiedzią, w której widać źródła

Możesz zwinąć widok źródeł.

Prompt z odpowiedzią i źródłami zwinięty

Opcjonalnie możesz rozszerzyć podgląd linku o dodatkowe treści, takie jak:

Więcej informacji o niektórych Google Maps dostawcach danych i ich warunkach licencji znajdziesz w informacjach prawnych dotyczących Map Google i Google Earth.

Google Maps wytyczne dotyczące przypisywania tekstu

Gdy przypisujesz źródła do Google Maps w tekście, postępuj zgodnie z tymi wytycznymi:

  • Nie modyfikuj w żaden sposób tekstu Google Maps:

    • Nie zmieniaj wielkości liter w tekście Google Maps.
    • Nie dziel tekstu Google Maps na kilka wierszy.
    • Nie tłumacz tekstu Google Maps na inny język.
    • Uniemożliwiaj przeglądarkom tłumaczenie tekstu Google Maps, używając atrybutu HTML translate="no".

  • Stylizuj tekst Google Maps zgodnie z opisem w tej tabeli:

    Właściwość Styl
    Rodzina czcionek Roboto. Wczytywanie czcionki jest opcjonalne.
    Zapasowa rodzina czcionek Dowolna czcionka bezszeryfowa używana już w Twoim produkcie lub "Sans-Serif" aby wywołać domyślną czcionkę systemową.
    Styl czcionki Normalnie
    Grubość czcionki 400
    Kolor czcionki Biały, czarny (#1F1F1F) lub szary (#5E5E5E). Zachowaj kontrast dostępny (4,5:1) względem tła.
    Rozmiar czcionki Minimalny rozmiar czcionki: 12sp
    Maksymalny rozmiar czcionki: 16sp
    Więcej informacji o jednostkach sp znajdziesz na stronie Material Design w artykule Font size units.
    Odstępy Normalnie

Przykładowy kod CSS

Ten kod CSS renderuje tekst Google Maps z odpowiednim stylem typograficznym i kolorem na białym lub jasnym tle.

@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;
}

Buforowanie tokena kontekstu i identyfikatora miejsca

The Google Maps Wynik oparty na Mapach Google może zawierać token kontekstu i identyfikator miejsca. Możesz buforować, przechowywać i eksportować te dane odpowiedzi:

  • (Tylko pakiet SDK na potrzeby internetu) googleMapsWidgetContextToken
  • placeId

Ograniczenia dotyczące zapisywania w pamięci podręcznej w Warunkach korzystania z powiązania ze źródłami informacji przy użyciu Map Google nie mają zastosowania do tych danych.

Zabronione działania i terytoria

W przypadku groundingu z użyciem Google Maps obowiązują dodatkowe ograniczenia dotyczące niektórych treści i działań, które mają na celu utrzymanie bezpiecznej i niezawodnej platformy. Oprócz ograniczeń dotyczących użytkowania określonych w Warunkach korzystania z usługi wybranego przez Ciebie Gemini API dostawcy: Gemini Developer API lub Agent Platform Gemini API (formerly Vertex AI) (patrz Warunki korzystania z usługi sekcja w Szczegółowych warunkach korzystania z usługi).

  • Nie będziesz używać groundingu z użyciem Google Maps do działań wysokiego ryzyka w tym do usług reagowania na sytuacje kryzysowe.

  • Nie będziesz rozpowszechniać ani sprzedawać aplikacji, która oferuje grounding z Google Maps na terytorium objętym zakazem. Więcej informacji znajdziesz w artykule Terytoria objęte zakazem Google Maps Platform. Lista terytoriów objętych zakazem może być okresowo aktualizowana.

Wyniki oparte na faktach i monitorowanie wykorzystania AI w konsoli Firebase

Jeśli włączysz monitorowanie wykorzystania AI w konsoliFirebase, odpowiedzi będą przechowywane w Cloud Logging. Domyślnie te dane mają 30-dniowy okres przechowywania.

Twoim obowiązkiem jest upewnienie się, że ten okres przechowywania lub dowolny niestandardowy okres ustawiony przez Ciebie jest w pełni zgodny z Twoim konkretnym przypadkiem użycia i dodatkowymi wymaganiami dotyczącymi zgodności w przypadku wybranego przez Ciebie Gemini API dostawcy: Gemini Developer API lub Agent Platform Gemini API (formerly Vertex AI) (patrz Warunki korzystania z usługi sekcja w Szczegółowych warunkach korzystania z usługi). Aby spełnić te wymagania, może być konieczne dostosowanie okresu przechowywania w usłudze Cloud Logging.

Ceny i limity zapytań

Ceny groundingu z użyciem Google Maps są oparte na zapytaniach. Żądanie jest wliczane do limitu Google Maps tylko wtedy, gdy prompt pomyślnie zwraca co najmniej 1 Google Maps wynik oparty na Mapach Google (co oznacza, że odpowiedź zawiera co najmniej 1 źródło z Google Maps). Jeśli w ramach jednego żądania do Google Maps zostanie wysłanych kilka zapytań, będzie się ono liczyć jako 1 żądanie w ramach limitu zapytań.

Zapoznaj się ze szczegółami dotyczącymi cen, dostępności modelu i limitów groundingu z użyciem Google Maps w dokumentacji wybranego przez Ciebie dostawcyGemini API dokumentacja: Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI).