The latest Gemini models, like Gemini 3.5 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

Grounding z Google Maps łączy model Gemini z danymi geoprzestrzennymi z Google Maps, dzięki czemu możesz tworzyć w aplikacjach funkcje oparte na lokalizacji.

Uziemienie za pomocą Google Maps ma te zalety:

Zwiększanie dokładności: zmniejsz 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 modelu.

Obsługiwane modele

gemini-3.1-pro-preview
gemini-3.5-flash
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.

Ugruntowanie modelu 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 znajdziesz ogólne sprawdzone metody korzystania z funkcji Grounding w Google Maps oraz informacje o tym, jak wykorzystać właściwości miejsca, aby poprawić wyniki.

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 Google Maps dane są wykorzystywane do odpowiadania na ich zapytania. Udostępnianie 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 służyć 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żą do określania typów pytań, na które może odpowiadać Grounding z Google Maps.

Przykładowe właściwości miejsca

Ta lista zawiera przykłady właściwości miejsc, 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
Przyjazny zwierzętom
Oferuje piwo
Oferuje dania wegetariańskie
Dostępne dla niepełnosprawnych
Wi-Fi

Odpowiedzi dotyczące miejsca to odpowiedzi z funkcji 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 udziela trafnych 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 „The Italian Place” to dobre miejsce dla dzieci i czy oferuje jedzenie na wynos? Jaką mają ocenę?
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: Potrzebuję restauracji z wejściem przystosowanym do wózków inwalidzkich.
Znajdowanie miejsca na przekąskę późną nocą: 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 w kawiarni: 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 Mapsweryfikowanych wynikach mogą różnić się od rzeczywistych warunków na drodze.

Jak działa uziemienie za pomocą Google Maps

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

Oto proces działania 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 ulepszyć odpowiedź, np. jeśli prompt zawiera kontekst geograficzny (np. „kawiarnie w pobliżu”, „muzea w San Francisco”).
Wywołuje narzędzie: model, rozpoznając intencję geograficzną, wywołuje narzędzie Google Maps.
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ć w konfiguracji narzędzia (lub nawet bezpośrednio w prompcie) szerokość i długość geograficzną, 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.
Przetwarza wyniki Google Maps: model przetwarza wyniki Google Maps i formułuje odpowiedź na pierwotny prompt.
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 modelu Google Maps jako narzędzia 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 więc nie będzie Google Mapswynikiem opartym na informacjach.

Interpretowanie wyników

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 Mapsuzasadnionym wyniku 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 tym, jak spełniać wymagania dotyczące korzystania z usług, 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ź, 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 opisano wymagania dotyczące korzystania z usługi Grounding withGoogle Maps w przypadku wybranego dostawcy Gemini API:Gemini Developer API lub Vertex AI Gemini API (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 prezentujesz 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:

Źródła Google Maps muszą następować bezpośrednio po wygenerowanych treściach, które obsługują. Wygenerowane treści są też nazywane Google Mapswynikami opartymi na faktach.
Ź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
    }
  }
}

Wyświetl Google Maps źródła z Google Maps linkami

W przypadku każdego źródła w groundingChunks musi zostać wygenerowany podgląd linku zgodnie z tymi wymaganiami:

Podaj atrybucję każdego źródła w formacie Google Maps zgodnie z Google Mapswytycznymi dotyczącymi atrybucji tekstu.
Wyświetl tytuł źródła podany w odpowiedzi.
Połącz ze źródłem za pomocą elementu 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 wzbogacić podgląd linku o dodatkowe treści, takie jak:

A Google Maps favicon wstawiona przed Google Maps atrybucją tekstową.
Zdjęcie ze źródłowego adresu URL (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.

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

Sformatuj tekst Google Maps zgodnie z opisem w tej tabeli:

Właściwość	Styl
Rodzina czcionek	Roboto. Wczytywanie czcionki jest opcjonalne.
Rodzina czcionek rezerwowych	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 względem tła na poziomie 4,5:1.
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	Normalny

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 MapsWynik oparty na informacjach 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

Uziemianie za pomocą Google Maps podlega dodatkowym ograniczeniom w przypadku niektórych treści i aktywności, aby zapewnić bezpieczeństwo i niezawodność platformy. Oprócz ograniczeń w korzystaniu określonych w Warunkach wybranego dostawcy Gemini API: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ć 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 konsoli Firebase

Jeśli włączysz monitorowanie AI w Firebasekonsoli, odpowiedzi będą przechowywane w Cloud Logging. Domyślnie okres przechowywania tych danych wynosi 30 dni.

Twoim obowiązkiem jest dopilnowanie, aby ten okres przechowywania lub dowolny okres niestandardowy, który ustawisz, 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 Vertex AI Gemini API (patrz sekcja Warunki korzystania z usługi w Warunkach dodatkowych dotyczących poszczególnych usług). Aby spełnić te wymagania, może być konieczne dostosowanie okresu przechowywania w 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 Maps wynik oparty na informacjach (czyli 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 szybkości.

Zapoznaj się ze szczegółami dotyczącymi cen, dostępności modelu i limitów w przypadku ugruntowania za pomocą Google Maps w dokumentacji wybranego dostawcy Gemini 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

Ugruntowanie modelu za pomocą Google Maps

Swift

Kotlin

Java

Web

Dart

Unity

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

Ogólne sprawdzone metody

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

Przykładowe właściwości miejsca

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

Jak działa uziemienie za pomocą Google Maps

Interpretowanie wyników

Wymagania dotyczące korzystania z usługi

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

Swift

Kotlin

Java

Web

Dart

Unity

Wyświetl Google Maps źródła z Google Maps linkami

Google Maps wskazówki dotyczące informacji o pochodzeniu tekstu,

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

Grounding z użyciem Map Google