The latest Gemini models, like Gemini 3.6 Flash, are available to use with Firebase AI Logic! Learn more.

All Imagen models will shut down as early as June 30, 2026. Learn about migrating your apps to use Nano Banana.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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 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.
Dostarczanie kontekstu wizualnego: buduj zaufanie użytkowników, integrując interaktywne widżety map, zdjęcia i Street View bezpośrednio obok twierdzeń modelu opartych na lokalizacji.

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

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.
Podaj 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 uziemienia 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. Udostępnianie 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 dokumencie Google Maps widget w dokumentacji 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 trafne odpowiedzi na podstawie danych powiązanych z miejscami w Google Maps.

Zaplanuj kolację rodzinną: 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?
Sprawdź dostępność dla znajomego: sprawdź, czy lokalizacja spełnia określone potrzeby w zakresie dostępności.
- Przykładowy prompt: Potrzebuję restauracji z wejściem dla wózków inwalidzkich.
Znajdź miejsce na przekąskę późnym wieczorem: znajdź otwarty lokal, który serwuje określony posiłek w określonym czasie.
- Przykładowy prompt: Czy "Burger Joint" jest teraz otwarty? Czy serwują kolację?_ Jakie są godziny otwarcia w piątek?
Spotkaj się 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 uziemionych 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:

Otrzymuje prompt: Twoja aplikacja wysyła prompt do modelu Gemini z włączonym narzędziem GoogleMaps.
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”).
Wywołuje narzędzie: model, rozpoznając intencje geograficzne, wywołuje narzędzie uziemienia za pomocą Google Maps.
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 raczej nie będą uwzględniać wyraźnej lokalizacji.
Przetwarza wynikiGoogle Maps: model przetwarza wyniki Google Maps i formułuje odpowiedź na pierwotny prompt.
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 kontekstowego widżetu Google Maps w aplikacji na potrzeby interakcji wizualnej. Więcej informacji o widżecie kontekstowym znajdziesz w Widżet uziemienia za pomocą Google Maps widget w dokumentacji.Google Maps

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 twierdzeń 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ą tekst odpowiedzi modelu text ze źródłami w groundingChunks. Każdy fragment łączy segment tekstu (określony przez startIndex i endIndex) z co najmniej 1 elementem groundingChunkIndices. To pole pomaga tworzyć linki do źródeł w tekście. Dowiedz się, jak spełnić wymagania dotyczące korzystania z usługi w dalszej części tej strony.
(Tylko pakiet SDK na potrzeby internetu) googleMapsWidgetContextToken: token tekstowy, którego można użyć do renderowania kontekstowego widżetu 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
    }
  }
}

Wyświetlanie źródeł Google Maps za pomocą linków Google Maps

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

Przypisz każde źródło do Google Maps zgodnie ze Google Maps wskazówkami dotyczącymi przypisywania tekstu.
Wyświetl tytuł źródła podany w odpowiedzi.
Połącz ze źródłem za pomocą uri z odpowiedzi.

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:

Favikona wstawiona przed przypisaniem tekstu.Google MapsGoogle Maps
Zdjęcie z adresu URL źródła (og:image).

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.

Wskazówki dotyczące przypisywania tekstuGoogle Maps

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

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 Rozmiary czcionek w 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ń dotyczących korzystania z usługi 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 kryzysowego.
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 ustawiony przez Ciebie okres niestandardowy jest w pełni zgodny z Twoim konkretnym przypadkiem użycia i 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ń, jest ono liczone jako 1 żądanie w ramach limitu zapytań.

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

Grounding z użyciem Map Google Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Obsługiwane modele

Obsługiwane języki

Uziemianie modelu za pomocą Google Maps

Swift

Kotlin

Java

Web

Dart

Unity

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

Ogólne sprawdzone metody

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

Przykładowe właściwości miejsca

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

Jak działa uziemienie za pomocą Google Maps

Interpretowanie wyniku uziemionego

Wymagania dotyczące korzystania z usługi

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

Swift

Kotlin

Java

Web

Dart

Unity

Wyświetlanie źródeł Google Maps za pomocą linków Google Maps

Wskazówki dotyczące przypisywania tekstuGoogle Maps

Przykładowy kod CSS

Buforowanie tokena kontekstu i identyfikatora miejsca

Zabronione działania i terytoria

Wyniki oparte na faktach i monitorowanie wykorzystania AI w konsoli Firebase

Ceny i limity zapytań

Grounding z użyciem Map Google