Fundierung mit Google Maps

Die Fundierung mit Google Maps verbindet ein Gemini-Modell mit Geodaten aus Google Maps, sodass Sie standortbezogene Funktionen in Ihre Anwendungen einbinden können.

Die Fundierung mit Google Maps bietet folgende Vorteile:

  • Faktische Genauigkeit erhöhen: Reduzieren Sie Modellhalluzinationen, indem Sie Antworten auf der Google-Datenbank mit über 250 Millionen realen Orten und Unternehmen basieren lassen.
  • Echtzeitinformationen abrufen: Beantworten Sie Fragen mithilfe von Livedaten, z. B. zu aktuellen Öffnungszeiten und zum Echtzeitstatus von Ladestationen für Elektrofahrzeuge.
  • Quellen angeben: Sie können das Vertrauen der Nutzer stärken, indem Sie Google Maps Ortsquellen und Links direkt neben den standortbezogenen Aussagen des Modells anzeigen.

Unterstützte Modelle

  • gemini-4-argon
  • 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)

Die Modelle gemini-3.1-pro-preview und die allgemeinen Gemini 2.5-Modelle (die verworfen wurden) unterstützen diese Funktion ebenfalls.

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, die das Modell zum Generieren der Antwort verwenden kann.

Swift 


import CoreLocation
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: [.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, die für Ihren Anwendungsfall und Ihre App geeignet sind.

Best Practices und Tipps zur Verbesserung der Ergebnisse

In diesem Abschnitt werden einige allgemeine Best Practices für die Verwendung der Fundierung mit Google Maps beschrieben. Außerdem wird erläutert, 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 „Fundierung mit Google Maps“ gewähren, wenn der Anwendungsfall einen klaren geografischen Kontext hat.

  • Nutzerstandort angeben: Wenn Sie möglichst relevante und personalisierte Antworten erhalten möchten (und der Standort des Nutzers bekannt ist), geben Sie den Standort des Nutzers (mit Breiten- und Längengrad über latLng) in der Konfiguration des Tools „Fundierung mit Google Maps“ an.

  • Endnutzer informieren: Informieren Sie Ihre Endnutzer klar darüber, dass Google Maps-Daten zur Beantwortung ihrer Anfragen verwendet werden. Die Bereitstellung der Quellen aus Google Maps für Endnutzer ist eine Anforderung für die Dienstnutzung 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 und von der Fundierung mit Google Maps zum Generieren von Antworten verwendet werden. Diese Attribute werden verwendet, um die Arten von Fragen zu bestimmen, die die Fundierung mit Google Maps beantworten kann.

Beispielattribute für Orte

Diese Liste enthält eine alphabetische Auswahl von Attributen zu Orten, die Ihr Modell zum Generieren von Antworten verwenden kann.

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

Ortsantworten sind eine Antwort von Fundierung mit Google Maps, die auf Informationen aus Nutzerrezensionen basiert.

Beispiel-Prompts, in denen Ortsattribute verwendet werden

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

  • Familienessen planen: Sie können herausfinden, ob ein Restaurant für eine Familie geeignet ist und ob es einen praktischen Service bietet.

    • Beispielprompt: Ist „The Italian Place“ für Kinder geeignet und wird dort Essen zum Mitnehmen angeboten? Wie ist die 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 einem rollstuhlgerechten Eingang.

  • Einen Ort für einen Mitternachtssnack finden: Ein geöffnetes Lokal finden, das zu einer bestimmten Zeit ein bestimmtes Gericht serviert.

    • Beispiel-Prompt: Hat „Burger Joint“ jetzt geöffnet? Wird hier Abendessen serviert? Wie sind die Öffnungszeiten am Freitag?

  • Kunden auf einen Kaffee treffen: Beurteilen Sie die Eignung eines Cafés für ein Geschäftstreffen anhand der Ausstattung, des Angebots und der Zahlungsoptionen.

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

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

So funktioniert die Fundierung mit Google Maps

Wenn Sie dem Modell das GoogleMaps-Tool zur Verfügung stellen, übernimmt das Modell automatisch den gesamten Workflow zum Suchen, Verarbeiten und Zitieren von Informationen.

Hier ist der Workflow des Modells:

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

  2. Prompt analysieren: Das Modell analysiert den Prompt und bestimmt, ob Google Maps die Antwort verbessern kann, z. B. wenn der Prompt geografischen Kontext enthält (wie „Cafés in meiner Nähe“, „Museen in San Francisco“).

  3. Ruft das Tool auf: Das Modell erkennt die geografische Absicht und ruft das Tool „Fundierung mit Google Maps“ auf.

  4. Sendet Abfragen an Google Maps: Der Dienst „Fundierung mit Google Maps“ fragt Google Maps nach relevanten Informationen ab (z. B. Orte, Rezensionen, Fotos, Adressen, Öffnungszeiten).

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

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

  6. Gibt ein fundiertes Google Maps-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.

Wenn Sie dem Modell Google Maps als Tool zur Verfügung stellen, muss das Modell nicht immer das Google Maps-Tool verwenden, um seine Antwort zu generieren. In diesen Fällen enthält die Antwort kein groundingMetadata-Objekt und ist daher kein Google Maps-fundiertes Ergebnis.

Fundiertes Ergebnis verstehen

Wenn das Modell seine Antwort auf Google Maps-Ergebnissen fundiert, enthält die Antwort ein groundingMetadata-Objekt mit strukturierten Daten, die für die Überprüfung von Aussagen und die Erstellung einer umfassenden Quellenerfahrung 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, die die maps-Quellen (uri, placeId und title) enthalten.
  • groundingSupports: Ein Array von Blöcken, um die Modellantwort text mit den Quellen in groundingChunks zu verknüpfen. Jeder Block verknüpft einen Text segment (definiert durch startIndex und endIndex) mit einem oder mehreren groundingChunkIndices. Dieses Feld hilft Ihnen, Inline-Quellenlinks zu erstellen. Weitere Informationen zum Erfüllen der Anforderungen für die Dienstnutzung finden Sie weiter unten auf dieser Seite.

Hier ist 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 Dienstnutzung

In diesem Abschnitt werden die Anforderungen an die Dienstnutzung 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

Mit jedem Google Maps-fundierten Ergebnis erhalten Sie Quellen in groundingChunks, 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. Dieser generierte Inhalt wird 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-fundierten 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 gemäß den folgenden Anforderungen generiert werden:

Prompt mit Antwort, die Quellen enthält

Sie können die Ansicht der Quellen minimieren.

Prompt mit minimierter 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-Textzuordnung eingefügt wird.
  • Ein Foto von der Quell-URL (og:image).

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

Google Maps Richtlinie für Quellenangaben als Text

Wenn Sie Quellen für Google Maps im Text angeben, beachten Sie die folgenden Richtlinien:

  • Ändern Sie den Text Google Maps in keiner Weise:

    • Ändere nicht die Groß-/Kleinschreibung des Textes „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“ findest du 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 dargestellt.

@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 fundierte 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 den von Ihnen 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 die Fundierung mit Google Maps nicht für Tätigkeiten mit erhöhtem Risikopotenzial, einschließlich Notfalldiensten.

  • Sie dürfen Ihre Anwendung, die Fundierung mit Google Maps bietet, nicht in einem verbotenen Gebiet vertreiben oder vermarkten. 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 das KI-Monitoring in der Firebase-Konsole aktiviert haben, werden die Antworten in Cloud Logging gespeichert. Standardmäßig werden diese Daten 30 Tage lang aufbewahrt.

Es liegt in Ihrer Verantwortung, dafür zu sorgen, dass diese Aufbewahrungsdauer oder eine von Ihnen festgelegte benutzerdefinierte Dauer vollständig mit Ihrem spezifischen Anwendungsfall und allen zusätzlichen Compliance-Anforderungen für den von Ihnen ausgewählten Gemini API-Anbieter übereinstimmt: Gemini Developer API oder Agent Platform Gemini API (formerly Vertex AI) (siehe Abschnitt Nutzungsbedingungen für den Dienst in den dienstspezifischen Nutzungsbedingungen). Möglicherweise müssen Sie die Aufbewahrungsdauer in Cloud Logging anpassen, um diese Anforderungen zu erfüllen.

Preise und Ratenbegrenzungen

Die Preise für die Fundierung mit Google Maps basieren auf Abfragen. Eine Anfrage wird nur dann auf das Google Maps-Kontingent angerechnet, wenn ein Prompt erfolgreich mindestens ein Google Maps-fundiertes Ergebnis zurückgibt (d. h., die Antwort enthält mindestens eine Google Maps-Quelle). Wenn mehrere Abfragen von einer einzelnen Anfrage 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 des ausgewählten Gemini API-Anbieters an: Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI).