Erdung mit Google Maps

Durch die Fundierung mit Google Maps wird ein Gemini-Modell mit raumbezogenen Daten von Google Maps verbunden, sodass Sie standortbezogene Funktionen in Ihre Apps einbauen können.

Die Fundierung mit Google Maps bietet folgende Vorteile:

  • Faktische Richtigkeit erhöhen: Reduzieren Sie Modellhalluzinationen, indem Sie Antworten auf der Datenbank von Google mit über 250 Millionen realen Orten und Unternehmen basieren.
  • Echtzeitinformationen abrufen: Fragen mit Livedaten beantworten, z. B. mit aktuellen Öffnungszeiten und dem Echtzeitstatus von Ladestationen für Elektrofahrzeuge.
  • Visuellen Kontext bereitstellen: Bauen Sie Vertrauen bei den Nutzern auf, indem Sie interaktive Karten-Widgets, Fotos und Street View direkt neben den ortsbezogenen Behauptungen des Modells einbinden.

Unterstützte Modelle

  • 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

Unterstützte Sprachen

Unterstützte Sprachen für Gemini-Modelle

Modell mit Google Maps fundieren

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Wenn Sie die GenerativeModel-Instanz erstellen, geben Sie GoogleMaps als tool an, das das Modell zum Generieren der Antwort verwenden kann.

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

Einheit 


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

Hier erfahren Sie, wie Sie ein Modell auswählen, der für Ihren Anwendungsfall und Ihre App geeignet ist.

Die besten Ergebnisse erzielen Sie mit einer Temperatur von 1, 0 (der Standardwert für alle Gemini 2.5-Modelle und höher). Informationen zum Festlegen der Temperatur in der Modellkonfiguration

Best Practices und Tipps zur Verbesserung der Ergebnisse

In diesem Abschnitt werden einige allgemeine Best Practices für die Verwendung von Grounding mit Google Maps sowie die Nutzung von Ortsattributen zur Verbesserung der Ergebnisse beschrieben.

Allgemeine Best Practices

  • Tool nur bei Bedarf bereitstellen: Um Leistung und Kosten zu optimieren, geben Sie dem Modell nur dann Zugriff auf das Tool „Grounding mit Google Maps“, wenn der Anwendungsfall einen klaren geografischen Kontext hat.

  • Nutzerstandort angeben: Für die relevantesten und personalisierten Antworten (und wenn der Standort des Nutzers bekannt ist) sollten Sie den Standort des Nutzers (mit Breiten- und Längengrad über latLng) in die Grounding-Konfiguration mit dem Tool Google Maps einbeziehen.

  • Endnutzer informieren: Informieren Sie Ihre Endnutzer deutlich darüber, dass Google Maps-Daten verwendet werden, um ihre Anfragen zu beantworten. Die Bereitstellung der Quellen von Google Maps für Endnutzer ist eine Anforderung für die Nutzung des Dienstes für das Tool „Fundierung mit Google Maps“.

  • (Nur Web-SDK) Kontextbezogenes Widget von Google Maps rendern: Das kontextbezogene Widget wird mit dem Kontext-Token googleMapsWidgetContextToken gerendert, das in der Gemini API-Antwort zurückgegeben wird und zum Rendern visueller Inhalte von Google Maps verwendet werden kann. Weitere Informationen zum kontextbezogenen Widget finden Sie in der Google Maps-Dokumentation unter Fundierung mit dem Google Maps-Widget.

Ortsattribute in Prompts verwenden

In diesem Abschnitt werden Ortsattribute aufgeführt, die zur Beschreibung von Orten verwendet werden und die von Grounding mit Google Maps zum Generieren von Antworten verwendet werden. Mithilfe dieser Eigenschaften wird ermittelt, welche Arten von Fragen durch die Fundierung mit Google Maps beantwortet werden können.

Beispiel-Place-Properties

Diese Liste enthält eine alphabetisch sortierte Auswahl von Eigenschaften zu Orten, die von Ihrem Modell zum Generieren von Antworten verwendet werden können.

  • Adresse
  • Abholung vor dem Laden
  • Debitkarte
  • Entfernung
  • Kostenlose Parkplätze
  • Livemusik
  • Menü für Kinder
  • Öffnungszeiten
  • Zahlungsoptionen (z. B. Barzahlung oder Kreditkarte)
  • Antwort zu einem Ort
  • Haustierfreundlich
  • Bier
  • Vegetarische Speisen
  • Rollstuhlgerecht
  • WLAN

Ortsbezogene Antworten sind Antworten von Grounding mit Google Maps, die auf Informationen aus Nutzerrezensionen basieren.

Beispiel-Prompts mit Orts-Properties

In den folgenden Beispielen werden Orts-Properties in Prompts zu verschiedenen Arten von Orten verwendet. Bei der Fundierung mit Google Maps werden die Properties verwendet, um Ihre Intention zu verstehen. Anschließend werden relevante Antworten auf Grundlage der Daten zu Orten in Google Maps bereitgestellt.

  • Familienessen planen: Ermitteln, ob ein Restaurant für eine Familie geeignet ist und ob es einen praktischen Service bietet.

    • Beispiel-Prompt: Ist „The Italian Place“ gut für Kinder und bieten sie Essen zum Mitnehmen an? Wie ist ihre Bewertung?

  • Barrierefreiheit für einen Freund prüfen: Ermitteln Sie, ob der Ort bestimmte Anforderungen an die Barrierefreiheit erfüllt.

    • Beispiel-Prompt: Ich suche ein Restaurant mit rollstuhlgerechtem Eingang.

  • Einen Ort für einen Mitternachtssnack finden: Suchen Sie nach einem geöffneten Lokal, in dem zu einer bestimmten Zeit ein bestimmtes Gericht serviert wird.

    • Beispiel-Prompt: Ist „Burger Joint“ jetzt geöffnet? Wird hier Abendessen serviert? Welche Öffnungszeiten gelten am Freitag?

  • Mit einem Kunden in einem Café treffen: Bewerten Sie die Eignung eines Cafés für ein Geschäftstreffen anhand von Ausstattung, Angebot und Zahlungsoptionen.

    • Beispiel-Prompt: Hat das „Cafe Central“ WLAN? Gibt es hier Kaffee? Wie hoch ist das Preisniveau und werden Kreditkarten akzeptiert?

Beachten Sie, dass die Informationen in den Google Mapsfundierten Ergebnissen von den tatsächlichen Straßenverhältnissen abweichen können.

So funktioniert die Fundierung mit Google Maps

Wenn Sie dem Modell das Tool GoogleMaps zur Verfügung stellen, übernimmt es automatisch den gesamten Workflow der Suche, Verarbeitung und Quellenangabe von Informationen.

Workflow des Modells:

  1. Empfängt Prompt: Ihre App sendet einen Prompt an das Gemini-Modell, wobei das Tool GoogleMaps aktiviert ist.

  2. Prompt wird analysiert: Das Modell analysiert den Prompt und ermittelt, ob Google Maps die Antwort verbessern kann, z. B. wenn der Prompt geografische Informationen enthält (z. B. „Cafés in der Nähe“, „Museen in San Francisco“).

  3. Tool wird aufgerufen: Das Modell erkennt die geografische Intention und ruft das Tool Google Maps auf.

  4. Sendet Anfragen an Google Maps: Der Dienst „Grounding with Google Maps“ fragt Google Maps nach relevanten Informationen ab, z. B. nach Orten, Rezensionen, Fotos, Adressen und Öffnungszeiten.

    Sie können optional Breiten- und Längengrad in die Konfiguration des Tools einfügen (oder sogar direkt in den Prompt), um relevantere und personalisierte Google Maps-Ergebnisse zu erhalten. Das Tool ist ein textbasiertes Suchtool und funktioniert ähnlich wie die Suche auf Google Maps. Bei lokalen Anfragen („in meiner Nähe“) werden die Koordinaten verwendet, während spezifische oder nicht lokale Anfragen wahrscheinlich nicht vom expliziten Standort beeinflusst werden.

  5. Verarbeiten der Google Maps-Ergebnisse: Das Modell verarbeitet die Google Maps-Ergebnisse und formuliert eine Antwort auf den ursprünglichen Prompt.

  6. Gibt ein Google Maps-Fundiertes Ergebnis zurück: Das Modell gibt eine endgültige, nutzerfreundliche Antwort zurück, die auf den Google Maps-Ergebnissen basiert. Diese Antwort enthält:

    • Die Textantwort des Modells.
    • Ein groundingMetadata-Objekt mit den Google Maps-Ergebnissen und ‑Quellen.
    • (Nur Web-SDK) Optional ein googleMapsWidgetContextToken, mit dem Sie ein kontextbezogenes Google Maps-Widget in Ihrer App für die visuelle Interaktion rendern können. Weitere Informationen zum kontextbezogenen Widget finden Sie in der Google Maps-Dokumentation unter Grounding mit dem Google Maps-Widget.

Wenn Sie Google Maps als Tool für das Modell bereitstellen, muss das Modell nicht immer das Tool Google Maps verwenden, um seine Antwort zu generieren. In diesen Fällen enthält die Antwort kein groundingMetadata-Objekt und ist daher kein Google Maps-Fundierungsergebnis.

Fundiertes Ergebnis verstehen

Wenn das Modell seine Antwort auf Google Maps-Ergebnisse stützt, enthält die Antwort ein groundingMetadata-Objekt mit strukturierten Daten, die für die Überprüfung von Behauptungen und die Erstellung einer umfassenden Quellenübersicht in Ihrer Anwendung unerlässlich sind.

Das groundingMetadata-Objekt in einem Google Maps fundierten Ergebnis enthält die folgenden Informationen:

  • groundingChunks: Ein Array von Objekten, das die maps-Quellen (uri, placeId und title) enthält.
  • groundingSupports: Ein Array von Blöcken, um die Modellantwort text mit den Quellen in groundingChunks zu verbinden. Jeder Chunk verknüpft einen Text segment (definiert durch startIndex und endIndex) mit einem oder mehreren groundingChunkIndices. Mit diesem Feld können Sie Inline-Quellenlinks erstellen. Informationen dazu, wie Sie die Anforderungen an die Dienstnutzung erfüllen, finden Sie weiter unten auf dieser Seite.
  • (Nur Web-SDK) googleMapsWidgetContextToken: Ein Text-Token, mit dem ein kontextbezogenes Places-Widget gerendert werden kann. Dieses Feld wird nur zurückgegeben, wenn Sie das Web-SDK verwenden und den Parameter enableWidget auf true gesetzt haben.

Hier sehen Sie ein Beispiel für eine Antwort, die ein groundingMetadata-Objekt enthält:

{
  "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/..."
      }
    }
  ]
}

Anforderungen an die Dienstnutzung

In diesem Abschnitt werden die Anforderungen für die Nutzung des Dienstes für Grounding mit Google Maps für den von Ihnen ausgewählten Gemini API-Anbieter beschrieben: Gemini Developer API oder Vertex AI Gemini API (siehe Abschnitt Nutzungsbedingungen für Dienste in den dienstspezifischen Nutzungsbedingungen).

Nutzer über Google Maps-Quellen informieren

Für jedes Google Maps fundierte Ergebnis erhalten Sie in groundingChunks Quellen, die jede Antwort untermauern. Die folgenden Metadaten werden ebenfalls zurückgegeben:

  • Quell-URI
  • Titel
  • ID

Wenn Sie in Ihrer App Ergebnisse aus der Fundierung mit Google Maps präsentieren, müssen Sie die zugehörigen Google Maps-Quellen angeben und Ihre Nutzer über Folgendes informieren:

  • Die Google Maps-Quellen müssen direkt auf die generierten Inhalte folgen, die sie unterstützen. Diese generierten Inhalte werden auch als Google Maps Fundiertes Ergebnis bezeichnet.

  • Die Google Maps-Quellen müssen innerhalb einer Nutzerinteraktion sichtbar sein.

So rufen Sie Werte zum Anzeigen von Quellen aus dem Google Maps-Fundiertes Ergebnis ab:

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

Einheit 

// ...

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

Für jede Quelle in groundingChunks muss eine Linkvorschau generiert werden, die den folgenden Anforderungen entspricht:

Prompt mit Antwort, in der Quellen angegeben sind

Sie können die Ansicht der Quellen minimieren.

Prompt mit zusammengefasster Antwort und Quellen

Optional können Sie die Linkvorschau mit zusätzlichen Inhalten ergänzen, z. B.:

  • Ein Google Maps-Favicon wird vor der Google Maps-Textattributierung eingefügt.
  • Ein Foto von der Quell-URL (og:image).

Weitere Informationen zu einigen der Google Maps-Datenanbieter und ihren Lizenzbedingungen finden Sie in den rechtlichen Hinweisen zu Google Maps und Google Earth.

Google Maps Richtlinien für die Quellenangabe als Text

Wenn Sie Quellen im Text Google Maps zuordnen, halten Sie sich an diese Richtlinien:

  • Ändern Sie den Text Google Maps nicht:

    • Ändern Sie die Großschreibung des Texts Google Maps nicht.
    • Fügen Sie keinen Zeilenumbruch in den Text Google Maps ein.
    • Lokalisiere den Text Google Maps nicht in eine andere Sprache.
    • Verhindern Sie, dass Browser den Text Google Maps übersetzen, indem Sie das HTML-Attribut translate="no" verwenden.

  • Formatieren Sie den Text Google Maps wie in der folgenden Tabelle beschrieben:

    Attribut Stil
    Schriftfamilie Roboto Das Laden der Schriftart ist optional.
    Fallback-Schriftfamilie Eine beliebige serifenlose Schriftart, die bereits in Ihrem Produkt verwendet wird, oder „Sans-Serif“, um die Standardsystemschriftart aufzurufen
    Schriftstil Normal
    Schriftstärke 400
    Schriftfarbe Weiß, Schwarz (#1F1F1F) oder Grau (#5E5E5E). Achten Sie auf einen barrierefreien Kontrast von 4,5:1 zum Hintergrund.
    Schriftgröße Mindestschriftgröße: 12 sp
    Maximale Schriftgröße: 16 sp
    Weitere Informationen zu „sp“ finden Sie auf der Material Design-Website unter „Font size units“.
    Abstand Normal

Beispiel-CSS

Mit dem folgenden CSS wird der Text Google Maps mit dem entsprechenden typografischen Stil und der entsprechenden Farbe auf einem weißen oder hellen Hintergrund gerendert.

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

Zwischenspeichern von Kontext-Token und Orts-ID

Das Google Maps fundierte Ergebnis kann ein Kontext-Token und eine Orts-ID enthalten. Sie können die folgenden Antwortdaten im Cache speichern, speichern und exportieren:

  • (Nur Web-SDK) googleMapsWidgetContextToken
  • placeId

Die Einschränkungen für das Caching in den Nutzungsbedingungen für Fundierung mit Google Maps gelten nicht für diese Daten.

Unzulässige Aktivitäten und Gebiete

Für die Fundierung mit Google Maps gelten zusätzliche Einschränkungen für bestimmte Inhalte und Aktivitäten, um eine sichere und zuverlässige Plattform zu gewährleisten. Zusätzlich zu den Nutzungsbeschränkungen in den Nutzungsbedingungen für den von Ihnen ausgewählten Gemini API-Anbieter: Gemini Developer API oder Vertex AI Gemini API (siehe Abschnitt Nutzungsbedingungen in den dienstspezifischen Nutzungsbedingungen).

  • Sie verwenden Grounding mit Google Maps nicht für hochriskante Aktivitäten, einschließlich Notdiensten.

  • Sie vertreiben oder bewerben Ihre Anwendung, die Grounding mit Google Maps anbietet, nicht in einem verbotenen Gebiet. Weitere Informationen finden Sie unter Verbotene Gebiete der Google Maps Platform. Die Liste der verbotenen Gebiete kann gelegentlich aktualisiert werden.

Fundierte Ergebnisse und KI-Monitoring in der Firebase Console

Wenn Sie KI-Monitoring in der Firebase-Konsole aktiviert haben, werden Antworten in Cloud Logging gespeichert. Standardmäßig haben diese Daten eine Aufbewahrungsdauer von 30 Tagen.

Es liegt in Ihrer Verantwortung, dafür zu sorgen, dass diese Aufbewahrungsdauer oder ein von Ihnen festgelegter benutzerdefinierter Zeitraum vollständig mit Ihrem spezifischen Anwendungsfall und allen zusätzlichen Compliance-Anforderungen für Ihren ausgewählten Gemini API-Bereitsteller übereinstimmt:Gemini Developer API oder Vertex AI Gemini API (siehe Abschnitt Nutzungsbedingungen des Dienstes in den dienstspezifischen Nutzungsbedingungen). Möglicherweise müssen Sie den Aufbewahrungszeitraum in Cloud Logging anpassen, um diese Anforderungen zu erfüllen.

Preise und Ratenbegrenzungen

Die Fundierung mit Google Maps-Preisen basiert auf Anfragen. Eine Anfrage wird nur dann auf das Google Maps-Kontingent angerechnet, wenn durch einen Prompt mindestens ein Google Maps Fundiertes Ergebnis zurückgegeben wird. Das bedeutet, dass die Antwort mindestens eine Google Maps-Quelle enthält. Wenn in einer einzelnen Anfrage mehrere Abfragen an Google Maps gesendet werden, zählt dies als eine Anfrage für das Ratenlimit.

Weitere Informationen zu Preisen, Modellverfügbarkeit und Limits für die Fundierung mit Google Maps finden Sie in der Dokumentation Ihres Gemini API-Anbieters: Gemini Developer API | Vertex AI Gemini API.