Grounding z użyciem Map Google

Grounding z 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ększanie dokładności: ogranicz halucynacje modelu, opierając odpowiedzi na bazie danych Google zawierającej informacje o ponad 250 milionach miejsc i firm na całym świecie.
  • Dostęp do informacji w czasie rzeczywistym: odpowiadaj na pytania, korzystając z aktualnych danych, np. godzin otwarcia firmy i stanu stacji ładowania EV w czasie rzeczywistym.
  • Podawaj kontekst wizualny: buduj zaufanie użytkowników, integrując interaktywne widżety map, zdjęcia i Street View bezpośrednio z informacjami o lokalizacji podawanymi przez model.

Obsługiwane modele

  • gemini-3.1-pro-preview
  • gemini-3.8-flash (oraz starsze gemini-3.7-flash, gemini-3.6-flash i gemini-3.5-flash)
  • gemini-3.5-flash-lite (i starszy gemini-3.1-flash-lite)

Ogólne modele Gemini 2.5 obsługują tę funkcję, ale wszystkie zostały wycofane.

Obsługiwane języki

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

Ugruntuj model za pomocą Google Maps

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

Podczas tworzenia instancji GenerativeModel podaj GoogleMaps jako tool, z którego model może korzystać podczas 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 odpowiednie do Twojego przypadku użycia i aplikacji.

Sprawdzone metody i wskazówki, które pomogą Ci poprawić wyniki

W tej sekcji opisujemy ogólne sprawdzone metody korzystania z funkcji Grounding w Google Maps oraz sposoby 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ć skuteczność i koszty, udostępniaj modelowi narzędzie Grounding with Google Maps tylko wtedy, gdy przypadek użycia ma wyraźny kontekst geograficzny.

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

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

  • (Tylko pakiet SDK do internetu) Wyświetl Google Mapswidżet kontekstowy: widżet kontekstowy jest wyświetlany za pomocą tokena kontekstu, googleMapsWidgetContextToken, który jest zwracany w odpowiedzi Gemini API i może być używany do wyświetlania treści wizualnych z Google Maps. Więcej informacji o widżecie kontekstowym znajdziesz w sekcji Uziemienie za pomocą widżetu Google Maps w dokumentacji Google Maps.

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

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

Przykładowe właściwości miejsca

Ta lista zawiera przykłady właściwości miejsc w kolejności alfabetycznej, które mogą być używane przez model 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 zwierzętom
  • Oferuje piwo
  • Oferuje dania wegetariańskie
  • Dostępne dla niepełnosprawnych
  • Wi-Fi

Odpowiedzi dotyczące miejsca to odpowiedzi generowane przez Grounding z Google Maps na podstawie informacji pochodzących z opinii użytkowników.

Przykładowe prompty korzystające z właściwości miejsca

W przykładach poniżej używamy właściwości miejsca w promptach dotyczących różnych rodzajów miejsc. Powiązanie ze źródłem informacji przy użyciu Google Maps wykorzystuje właściwości, aby zrozumieć Twoje intencje, a następnie podaje trafne odpowiedzi na podstawie danych powiązanych z miejscami w Google Maps.

  • Zaplanuj rodzinny obiad: sprawdź, czy restauracja jest odpowiednia dla rodziny i czy oferuje wygodną obsługę.

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

  • Sprawdzanie dostępności dla znajomego: sprawdź, czy dane miejsce spełnia określone potrzeby związane z ułatwieniami dostępu.

    • Przykładowy prompt: Szukam restauracji z wejściem dla osób na wózkach inwalidzkich.

  • Znajdowanie miejsca na przekąskę późnym wieczorem: znajdź otwarty lokal serwujący określony posiłek w danym czasie.

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

  • Spotkanie z klientem przy kawie: oceń, czy kawiarnia nadaje się na spotkanie biznesowe, na podstawie udogodnień, oferty i opcji płatności.

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

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

Jak działa uziemienie za pomocą Google Maps

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

Oto proces działania 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 określa, czy Google Maps może ulepszyć odpowiedź, np. jeśli prompt zawiera kontekst geograficzny (np. „kawiarnie w pobliżu”, „muzea w San Francisco”).

  3. Wywołuje narzędzie: model, rozpoznając intencję geograficzną, wywołuje narzędzie Google Maps.

  4. Wysyła zapytania do Google Maps: usługa Grounding with Google Maps wysyła zapytania do Google Maps o odpowiednie informacje (np. miejsca, opinie, zdjęcia, adresy, godziny otwarcia).

    Możesz opcjonalnie uwzględnić szerokość i długość geograficzną w konfiguracji narzędzia (lub nawet bezpośrednio w prompcie), aby uzyskać bardziej trafne i spersonalizowaneGoogle Maps wyniki. To narzędzie do wyszukiwania tekstowego działa podobnie do wyszukiwania w Google Maps. Zapytania lokalne („w pobliżu”) będą korzystać ze współrzędnych, a zapytania konkretne lub nielokalne raczej nie będą zależeć od wyraźnej lokalizacji.

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

  6. Zwraca Google Maps wynik oparty na źródłach: model zwraca ostateczną, przyjazną dla użytkownika odpowiedź opartą na Google Maps wynikach. Ta odpowiedź zawiera:

    • Tekstowa odpowiedź modelu.
    • Obiekt groundingMetadata z wynikami Google Maps i źródłami.
    • (Tylko pakiet SDK na komputery) Opcjonalnie token googleMapsWidgetContextToken, który umożliwia renderowanie w aplikacji kontekstowego widżetu Google Maps do interakcji wizualnej. Więcej informacji o widżecie kontekstowym znajdziesz w sekcji Uziemianie za pomocą widżetu Google Maps w dokumentacji Google Maps.

Pamiętaj, że udostępnienie Google Maps modelu nie wymaga od niego zawsze używania narzędzia Google Maps do generowania odpowiedzi. W takich przypadkach odpowiedź nie będzie zawierać obiektu groundingMetadata, a więc nie będzie Google Mapswynikiem opartym na źródłach.

Interpretowanie wyniku opartego na informacjach

Jeśli model opiera swoją odpowiedź na Google Maps wynikach, zawiera ona obiekt groundingMetadata z danymi strukturalnymi, które są niezbędne do weryfikowania twierdzeń i tworzenia w aplikacji rozbudowanego źródła informacji.

Obiekt groundingMetadata w Google Mapswyniku z uzasadnieniem zawiera te informacje:

  • groundingChunks: tablica obiektów zawierająca źródła maps (uri, placeId i title).
  • groundingSupports: tablica fragmentów do połączenia odpowiedzi modelutext ze źródłami w groundingChunks. Każdy fragment łączy tekstsegment (zdefiniowany przez startIndex i endIndex) z co najmniej 1 groundingChunkIndices. To pole pomaga tworzyć wbudowane linki do źródeł. Więcej informacji o spełnianiu wymagań dotyczących korzystania z usługi znajdziesz w dalszej części tej strony.
  • (Tylko pakiet SDK do internetu) googleMapsWidgetContextToken: token tekstowy, którego można użyć do renderowania widżetu Miejsc kontekstowych. To pole jest zwracane tylko wtedy, gdy używasz pakietu Web SDK i ustawisz parametr enableWidget na true.

Oto przykładowa odpowiedź zawierająca 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 opisano wymagania dotyczące korzystania z usługi Grounding withGoogle Maps w przypadku wybranego dostawcy Gemini API:Gemini Developer API lub Agent Platform Gemini API (formerly Vertex AI) (patrz sekcja Warunki korzystania z usługi w Szczegółowych warunkach korzystania z usługi).

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

W przypadku każdego Google Mapswyniku opartego na źródłach otrzymasz źródłagroundingChunks, które potwierdzają każdą odpowiedź. Zwracane są też te metadane:

  • Identyfikator URI źródła
  • tytuł
  • Identyfikator

Gdy w aplikacji wyświetlasz wyniki uzyskane za pomocą funkcji Grounding z Google Maps, musisz podać powiązane Google Maps źródła i poinformować użytkowników o tych kwestiach:

  • Google Maps źródła muszą znajdować się bezpośrednio po wygenerowanych treściach, które obsługują. Te wygenerowane treści są też nazywane Google Mapswynikami opartymi na informacjach.

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

Aby uzyskać wartości do wyświetlania źródeł z Google Mapsuzasadnionego wyniku:

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 musi zostać wygenerowany 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 zwinięty

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

  • A Google Maps favicon inserted before the Google Maps text attribution.
  • Zdjęcie z adresu URL źródła (og:image).

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

Google Maps wskazówki dotyczące informacji o pochodzeniu 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".

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

    Właściwość Styl
    Rodzina czcionek Roboto. Wczytywanie czcionki jest opcjonalne.
    Zastępcza 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 dostępny kontrast (4,5:1) względem tła.
    Rozmiar czcionki Minimalny rozmiar czcionki: 12 sp
    Maksymalny rozmiar czcionki: 16 sp
    Więcej informacji o jednostce sp znajdziesz na stronie Material Design w sekcji Jednostki rozmiaru czcionki.
    Odstępy Normalnie

Przykładowy kod CSS

Poniższy 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

Google Maps Uzasadniony wynik może zawierać token kontekstu i identyfikator miejsca. Możesz buforować, przechowywać i eksportować te dane odpowiedzi:

  • (tylko pakiet SDK dla klienta internetowego) googleMapsWidgetContextToken
  • placeId

Ograniczenia dotyczące zapisywania w pamięci podręcznej w Warunkach korzystania z usługi 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 Google Maps obowiązują dodatkowe ograniczenia dotyczące niektórych treści i aktywności, aby zapewnić bezpieczeństwo i niezawodność platformy. Oprócz ograniczeń użytkowania określonych w Warunkach wybranego Gemini APIdostawcy: Gemini Developer API lub Agent Platform Gemini API (formerly Vertex AI) (patrz sekcja Warunki usługi w Szczegółowych warunkach korzystania z usługi).

  • Nie będziesz używać groundingu z Google Maps do czynności związanych z wysokim ryzykiem, w tym do usług wzywania służb ratowniczych.

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

Wyniki oparte na faktach i monitorowanie wykorzystania AI w Firebasekonsoli

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

Twoim obowiązkiem jest dopilnowanie, aby ten okres przechowywania lub dowolny ustawiony przez Ciebie okres niestandardowy był w pełni zgodny z Twoim konkretnym przypadkiem użycia i wszelkimi dodatkowymi wymaganiami dotyczącymi zgodności w przypadku wybranego Gemini APIdostawcy:Gemini Developer API lub Agent Platform Gemini API (formerly Vertex AI) (patrz sekcja Warunki usługi w Warunkach dodatkowych dotyczących poszczególnych usług). Aby spełnić te wymagania, może być konieczne dostosowanie okresu przechowywania w usłudze Cloud Logging.

Ceny i limity

Uziemienie z Google Maps cenami jest oparte na zapytaniach. Żądanie jest wliczane do limitu Google Maps tylko wtedy, gdy prompt zwróci co najmniej 1 Google Mapswynik oparty na informacjach (co oznacza, że odpowiedź zawiera co najmniej 1 Google Mapsźródło). Jeśli w ramach jednego żądania do usługiGoogle Maps zostanie wysłanych kilka zapytań, będzie to liczone jako 1 żądanie w ramach limitu żądań.

Zapoznaj się ze szczegółami dotyczącymi cen, dostępności modeli i limitów w przypadku funkcji Grounding z Google Maps w dokumentacji wybranego dostawcy Gemini API:Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI).