Grounding z użyciem Map Google

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

Uziemienie za pomocą 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 miejsc i firm z całego świata.
  • 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: buduj 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-flash-preview
  • gemini-3.1-flash-lite
  • gemini-2.5-pro
  • gemini-2.5-flash
  • gemini-2.5-flash-lite

Obsługiwane języki

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

Uziemianie modelu za pomocą Google Maps

Kliknij swojego dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod specyficzne dla 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ą dla Twojego przypadku użycia i aplikacji.

Aby uzyskać optymalne wyniki, użyj temperatury 1.0 (która jest domyślną wartością dla wszystkich modeli Gemini 2.5 i nowszych). Dowiedz się, jak ustawić temperaturę w konfiguracji modelu.

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

W tej sekcji opisujemy ogólne sprawdzone metody korzystania z uziemienia za pomocą 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 narzędzie uziemienia za pomocą Google Maps tylko 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 latLng) w konfiguracji narzędzia powiązania ze źródłem informacji za pomocą Google Maps.

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

  • (Tylko pakiet SDK na potrzeby internetu) Wyświetlaj 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 sekcji Widżet uziemienia za pomocąGoogle 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 uziemienie za pomocą Google Maps do generowania odpowiedzi. Te właściwości służą do określania typów pytań, na które może odpowiadać uziemienie za pomocą Google Maps

Przykładowe właściwości miejsca

Ta lista zawiera alfabetyczny wykaz 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 uziemienia za pomocą 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. Uziemienie za pomocą Google Maps używa tych właściwości, aby zrozumieć Twoje intencje, a następnie podaje odpowiednie 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 faktach mogą się różnić od rzeczywistych warunków na drodze.

Jak działa uziemienie za pomocą 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 uziemienia za pomocą Google Maps.

  4. Wysyła zapytania do Google Maps: usługa uziemienia za pomocą 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 prawdopodobnie 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 uziemiony: model zwraca ostateczną, przyjazną dla użytkownika odpowiedź, która jest oparta na wynikach Google Maps. 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 wizualnej. Więcej informacji o widżecie kontekstowym znajdziesz w dokumentacji Google Maps w sekcji Widżet uziemienia za pomocą Google Maps widżetu.

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 niebędzie Google Maps wynikiem uziemionym.

Interpretowanie wyniku uziemionego

Jeśli model uziemia swoją odpowiedź na podstawie wyników Google Maps, 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 uziemionym zawiera te informacje:

  • groundingChunks: tablica obiektów zawierających źródła maps (uri, placeId i title).
  • groundingSupports: tablica fragmentów, które łączą odpowiedź 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 uziemienia za pomocą Google Maps w przypadku wybranego Gemini API dostawcy: Gemini Developer API lub Vertex AI Gemini API (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 uziemionego 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 uziemienia za pomocą 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 uziemionym.

  • Ź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 uziemionego:

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ą zawierającą źródła

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

Prompt z odpowiedzią i źródłami w formie zwiniętej

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 tekstu Google Maps w żaden sposób:

    • 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 Normalny
    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 sp znajdziesz na stronie Rozmiar czcionki w witrynie Material Design.
    Odstępy Normalny

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

Uziemienie za pomocą Google Maps ma dodatkowe ograniczenia dotyczące niektórych treści i działań, aby zapewnić bezpieczeństwo i niezawodność platformy. Oprócz ograniczeń użytkowania określonych w Warunkach korzystania z usługi wybranego Gemini API dostawcy: Gemini Developer API lub Vertex AI Gemini API (patrz sekcja Warunki korzystania z usługi w Szczegółowych warunkach korzystania z usługi).

  • Nie będziesz używać uziemienia za pomocą 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 uziemienie za pomocą 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 wszelkimi dodatkowymi wymaganiami dotyczącymi zgodności w przypadku wybranego dostawcy Gemini API: Gemini Developer API lub Vertex AI Gemini API (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 uziemienia za pomocą 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 uziemiony (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 ono liczone jako 1 żądanie w ramach limitu zapytań.

Zapoznaj się ze szczegółami dotyczącymi cen, dostępności modelu i limitów powiązania ze źródłem informacji za pomocą Google Maps w dokumentacji wybranego dostawcyGemini API interfejsu API: Gemini Developer API | Vertex AI Gemini API.