Fundierung mit Google Maps

Durch die Fundierung mit Google Maps wird ein Gemini-Modell mit Geodaten 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.
  • Quellen angeben: Bauen Sie Vertrauen bei den Nutzern auf, indem Sie Google Maps-Quellen und Links direkt neben den standortbezogenen Behauptungen des Modells anzeigen.

Unterstützte Modelle

  • gemini-3.1-pro-preview
  • gemini-3.8-flash (und die älteren gemini-3.7-flash, gemini-3.6-flash und gemini-3.5-flash)
  • gemini-3.5-flash-lite (und die ältere gemini-3.1-flash-lite)

Gemini 2.5-Modelle für den allgemeinen Gebrauch unterstützen diese Funktion, sie sind jedoch alle eingestellt.

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.
    tools: [ { googleMaps: {} } ],
    // 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-US',
  ),
);

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

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 beschrieben. Außerdem erfahren Sie, wie Sie Ortsattribute nutzen können, um die Ergebnisse zu verbessern.

Allgemeine Best Practices

  • Tool nur bei Bedarf bereitstellen: Um Leistung und Kosten zu optimieren, sollten Sie dem Modell nur dann Zugriff auf das Tool „Grounding with Google Maps“ gewähren, 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 Toolkonfiguration für die Fundierung mit Google Maps aufnehmen.

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

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 für Ortsattribute

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 Ort
  • Haustiere erlaubt
  • 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 lautet die Bewertung?

  • Barrierefreiheit für einen Freund prüfen: Sie können herausfinden, 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: Finden Sie ein geöffnetes 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 einen Kaffee trinken: Bewerten Sie die Eignung eines Cafés für ein Geschäftstreffen anhand von Annehmlichkeiten, Angeboten und Zahlungsoptionen.

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

Die Informationen in den Google Maps fundierten Ergebnissen können von den tatsächlichen Straßenverhältnissen abweichen.

So funktioniert Grounding 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 geografischen Kontext enthält (z. B. „Cafés in meiner Nähe“, „Museen in San Francisco“).

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

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

    Optional können Sie Breiten- und Längengrad in die Konfiguration des Tools oder direkt in den Prompt einfügen, um relevantere und personalisierte Google Maps-Ergebnisse zu erhalten. Das Tool ist ein Text Search Tool 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-Fundierungsergebnis 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.

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.

Fundierte Ergebnisse 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 Objekt groundingMetadata in einem Google Maps Grounded Result 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.

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

Anforderungen an die Nutzung von Diensten

In diesem Abschnitt werden die Anforderungen für die Nutzung des Dienstes für die Fundierung mit Google Maps für den von Ihnen ausgewählten Gemini API-Anbieter beschrieben: Gemini Developer API oder Agent Platform Gemini API (formerly Vertex AI) (siehe Abschnitt Dienstbedingungen 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 unmittelbar 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 erhalten Sie Werte für die Anzeige von Quellen aus dem Google Maps fundierten Ergebnis:

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 erweitern, z. B.:

  • Ein Google Maps-Favicon, das vor der Google Maps-Textkennzeichnung eingefügt wird.
  • 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 die folgenden Richtlinien:

  • Ändern Sie den Text Google Maps nicht:

    • Ändern Sie nicht die Groß- und Kleinschreibung des Texts Google Maps.
    • Fügen Sie keinen Zeilenumbruch in den Text Google Maps ein.
    • Übersetze 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;
}

Caching von Orts-IDs

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

  • placeId

Die Einschränkungen für das Caching in den Nutzungsbedingungen für die 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 Ihren ausgewählten Gemini API-Anbieter: Gemini Developer API oder Agent Platform Gemini API (formerly Vertex AI) (siehe Abschnitt Nutzungsbedingungen in den dienstspezifischen Nutzungsbedingungen).

  • Sie verwenden Grounding mit Google Maps nicht für Tätigkeiten mit erhöhtem Risikopotenzial, z. B. Notfalldienste.

  • Sie werden Ihre Anwendung, die Grounding mit Google Maps anbietet, nicht in einem verbotenen Gebiet vertreiben oder bewerben. 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-Konsole

Wenn Sie KI-Monitoring in der Firebase-Konsole aktiviert haben, werden Antworten in Cloud Logging gespeichert. Standardmäßig werden diese Daten 30 Tage lang aufbewahrt.

Es liegt in Ihrer Verantwortung, dafür zu sorgen, dass dieser Aufbewahrungszeitraum 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-Anbieter übereinstimmt: Gemini Developer API oder Agent Platform Gemini API (formerly Vertex AI) (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 wird anhand von Anfragen abgerechnet. Eine Anfrage wird nur dann auf das Google Maps-Kontingent angerechnet, wenn durch einen Prompt mindestens ein Google Maps-Fundierungs-Ergebnis zurückgegeben wird (d. h., wenn die Antwort mindestens eine Google Maps-Quelle enthält). Wenn in einer einzelnen Anfrage mehrere Abfragen an Google Maps gesendet werden, wird dies als eine Anfrage auf das Ratenlimit angerechnet.

Sehen Sie sich die Details zu Preisen, Modellverfügbarkeit und Limits für die Fundierung mit Google Maps in der Dokumentation Ihres ausgewählten Gemini API-Anbieters an: Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI).