Grounding z użyciem Map Google

Powiązanie ze źródłem informacji przy użyciu Map Google łączy generatywne możliwości Gemini z bogatymi, aktualnymi i opartymi na faktach danymi z Map Google. Dzięki tej funkcji deweloperzy mogą łatwo wprowadzać w swoich aplikacjach funkcje oparte na lokalizacji. Gdy zapytanie użytkownika ma kontekst związany z danymi z Map, model Gemini korzysta z Map Google, aby udzielać dokładnych i aktualnych odpowiedzi, które są istotne dla określonej przez użytkownika lokalizacji lub ogólnego obszaru.

• Dokładne odpowiedzi oparte na lokalizacji: wykorzystuj obszerne i aktualne dane z Map Google w przypadku zapytań dotyczących konkretnych lokalizacji.
• Ulepszona personalizacja: dostosowuj rekomendacje i informacje na podstawie lokalizacji podanych przez użytkownika.
• Informacje kontekstowe i widżety: tokeny kontekstowe do renderowania interaktywnych widżetów Map Google obok wygenerowanych treści.

Rozpocznij

Ten przykład pokazuje, jak zintegrować powiązanie ze źródłem informacji przy użyciu Map Google z aplikacją, aby udzielać dokładnych odpowiedzi opartych na lokalizacji na zapytania użytkowników. Prompt prosi o lokalne rekomendacje z opcjonalną lokalizacją użytkownika, co umożliwia modelowi Gemini korzystanie z danych z Map Google.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "What are the best Italian restaurants within a 15-minute walk from here?"

response = client.models.generate_content(
    model='gemini-3.5-flash',
    contents=prompt,
    config=types.GenerateContentConfig(
        # Turn on grounding with Google Maps
        tools=[types.Tool(google_maps=types.GoogleMaps())],
        # Optionally provide the relevant location context (this is in Los Angeles)
        tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
            lat_lng=types.LatLng(
                latitude=34.050481, longitude=-118.248526))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in grounding.grounding_chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function generateContentWithMapsGrounding() {
  const response = await ai.models.generateContent({
    model: "gemini-3.5-flash",
    contents: "What are the best Italian restaurants within a 15-minute walk from here?",
    config: {
      // Turn on grounding with Google Maps
      tools: [{ googleMaps: {} }],
      toolConfig: {
        retrievalConfig: {
          // Optionally provide the relevant location context (this is in Los Angeles)
          latLng: {
            latitude: 34.050481,
            longitude: -118.248526,
          },
        },
      },
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const grounding = response.candidates[0]?.groundingMetadata;
  if (grounding?.groundingChunks) {
    console.log("-".repeat(40));
    console.log("Sources:");
    for (const chunk of grounding.groundingChunks) {
      if (chunk.maps) {
        console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
      }
    }
  }
}

generateContentWithMapsGrounding();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "What are the best Italian restaurants within a 15-minute walk from here?"
    }]
  }],
  "tools": [{"googleMaps": {}}],
  "toolConfig": {
    "retrievalConfig": {
      "latLng": {"latitude": 34.050481, "longitude": -118.248526}
    }
  }
}'

Jak działa powiązanie ze źródłem informacji przy użyciu Map Google

Powiązanie ze źródłami informacji przy użyciu Map Google integruje interfejs Gemini API z ekosystemem Google Geo, używając interfejsu API Map Google jako źródła informacji. Gdy zapytanie użytkownika zawiera kontekst geograficzny, model Gemini może wywołać narzędzie powiązania ze źródłem informacji przy użyciu Map Google. Model może wtedy generować odpowiedzi oparte na danych z Map Google związanych z podaną lokalizacją.

Proces ten zwykle obejmuje te etapy:

1. Zapytanie użytkownika: użytkownik przesyła zapytanie do Twojej aplikacji, które może zawierać kontekst geograficzny (np. „kawiarnie w pobliżu”, „muzea w San Francisco”).
2. Wywołanie narzędzia: model Gemini, rozpoznając intencję geograficzną, wywołuje narzędzie powiązania ze źródłem informacji przy użyciu Map Google. To narzędzie może opcjonalnie otrzymać od użytkownika latitude i longitude. Narzędzie to jest narzędziem wyszukiwania tekstowego i działa podobnie do wyszukiwania w Mapach. Zapytania lokalne („w pobliżu”) będą używać współrzędnych, a zapytania konkretne lub nielokalne raczej nie będą uwzględniać lokalizacji.
3. Pobieranie danych: usługa powiązania ze źródłem informacji przy użyciu Map Google wysyła zapytania do Map Google, aby uzyskać odpowiednie informacje (np. miejsca, opinie, zdjęcia, adresy, godziny otwarcia).
4. Generowanie na podstawie danych: pobrane dane z Map są używane do informowania odpowiedzi modelu Gemini, co zapewnia dokładność i trafność.
5. Token odpowiedzi i widżetu: model zwraca odpowiedź tekstową, która zawiera cytaty ze źródeł w Mapach Google. Opcjonalnie odpowiedź interfejsu API może też zawierać google_maps_widget_context_token, co umożliwia deweloperom renderowanie w aplikacji kontekstowego widżetu Miejsca do interakcji wizualnej.

Kiedy i dlaczego warto używać powiązania ze źródłem informacji przy użyciu Map Google

Powiązanie ze źródłem informacji przy użyciu Map Google jest idealne w przypadku aplikacji, które wymagają dokładnych, aktualnych i specyficznych dla lokalizacji informacji. Ulepsza wrażenia użytkowników, udostępniając trafne i spersonalizowane treści oparte na obszernej bazie danych Map Google, która zawiera ponad 250 milionów miejsc na całym świecie.

Powiązania ze źródłem informacji przy użyciu Map Google należy używać, gdy aplikacja musi:

• udzielać pełnych i dokładnych odpowiedzi na pytania dotyczące konkretnych lokalizacji;
• tworzyć konwersacyjne plannery podróży i lokalne przewodniki;
• rekomendować ciekawe miejsca na podstawie lokalizacji i preferencji użytkownika, np. restauracje lub sklepy;
• tworzyć oparte na lokalizacji funkcje dla usług społecznościowych, handlowych lub dostawy jedzenia.

Powiązanie ze źródłem informacji przy użyciu Map Google sprawdza się w przypadkach użycia, w których kluczowe są bliskość i aktualne dane, np. w przypadku wyszukiwania „najlepszej kawiarni w pobliżu” lub uzyskiwania wskazówek dojazdu.

Metody i parametry interfejsu API

Powiązanie ze źródłem informacji przy użyciu Map Google jest udostępniane przez interfejs Gemini API jako narzędzie w ramach metody generateContent. Powiązanie ze źródłem informacji przy użyciu Map Google możesz włączyć i skonfigurować , dodając obiekt googleMaps do parametru tools w żądaniu.

{
  "contents": [{
    "parts": [
      {"text": "Restaurants near Times Square."}
    ]
  }],
  "tools":  { "googleMaps": {} }
}

Narzędzie googleMaps może dodatkowo akceptować parametr logiczny enableWidget, który służy do określania, czy pole googleMapsWidgetContextToken ma być zwracane w odpowiedzi. Można go używać do wyświetlania kontekstowego widżetu Miejsca.

{
"contents": [{
    "parts": [
      {"text": "Restaurants near Times Square."}
    ]
  }],
  "tools":  { "googleMaps": { "enableWidget": true } }
}

Narzędzie obsługuje też przekazywanie lokalizacji kontekstowej jako toolConfig.

{
  "contents": [{
    "parts": [
      {"text": "Restaurants near here."}
    ]
  }],
  "tools":  { "googleMaps": {} },
  "toolConfig":  {
    "retrievalConfig": {
      "latLng": {
        "latitude": 40.758896,
        "longitude": -73.985130
      }
    }
  }
}

Omówienie odpowiedzi powiązania ze źródłem informacji

Gdy odpowiedź jest powiązana ze źródłem informacji przy użyciu danych z Map Google, odpowiedź zawiera groundingMetadata pole. Te uporządkowane dane są niezbędne do weryfikowania twierdzeń i tworzenia w aplikacji rozbudowanych cytatów, a także do spełniania wymagań dotyczących korzystania z usługi.

{
  "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"
            },
            // repeated ...
          }
        ],
        "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]
          },
          // repeated ...
        ],
        "webSearchQueries": [
          "restaurants near me"
        ],
        "googleMapsWidgetContextToken": "widgetcontent/..."
      }
    }
  ]
}

Interfejs Gemini API zwraca te informacje w polu groundingMetadata:

• groundingChunks: tablica obiektów zawierających źródła maps (uri, placeId i title).
• groundingSupports: tablica fragmentów, które łączą tekst odpowiedzi modelu ze źródłami w groundingChunks. Każdy fragment łączy zakres tekstu (zdefiniowany przez startIndex i endIndex) z co najmniej 1 elementem groundingChunkIndices. Jest to klucz do tworzenia cytatów w tekście.
• googleMapsWidgetContextToken: token tekstowy, którego można użyć do renderowania kontekstowego widżetu Miejsca.

Fragment kodu pokazujący, jak renderować cytaty w tekście, znajdziesz w przykładzie w dokumentacji powiązania ze źródłem informacji przy użyciu wyszukiwarki Google.

Wyświetlanie kontekstowego widżetu Map Google

Aby użyć zwróconego googleMapsWidgetContextToken, musisz wczytać interfejs Maps JavaScript API firmy Google.

Przypadki użycia

Powiązanie ze źródłem informacji przy użyciu Map Google obsługuje różne przypadki użycia oparte na lokalizacji. Te przykłady pokazują, jak różne prompty i parametry mogą wykorzystywać powiązanie ze źródłem informacji przy użyciu Map Google. Informacje w wynikach powiązanych z Mapami Google mogą się różnić od rzeczywistych warunków.

Obsługa pytań dotyczących konkretnych miejsc

Zadawaj szczegółowe pytania o konkretne miejsce, aby uzyskać odpowiedzi na podstawie opinii użytkowników Google i innych danych z Map.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "Is there a cafe near the corner of 1st and Main that has outdoor seating?"

response = client.models.generate_content(
    model='gemini-3.5-flash',
    contents=prompt,
    config=types.GenerateContentConfig(
        # Turn on the Maps tool
        tools=[types.Tool(google_maps=types.GoogleMaps())],

        # Provide the relevant location context (this is in Los Angeles)
        tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
            lat_lng=types.LatLng(
                latitude=34.050481, longitude=-118.248526))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if chunks := grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')
  ```

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function run() {
  const prompt = "Is there a cafe near the corner of 1st and Main that has outdoor seating?";

  const response = await ai.models.generateContent({
    model: 'gemini-3.5-flash',
    contents: prompt,
    config: {
      // Turn on the Maps tool
      tools: [{googleMaps: {}}],
      // Provide the relevant location context (this is in Los Angeles)
      toolConfig: {
        retrievalConfig: {
          latLng: {
            latitude: 34.050481,
            longitude: -118.248526
          }
        }
      }
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const chunks = response.candidates[0].groundingMetadata?.groundingChunks;
  if (chunks) {
    console.log('-'.repeat(40));
    console.log("Sources:");
    for (const chunk of chunks) {
      if (chunk.maps) {
        console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
      }
    }
  }
}

run();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Is there a cafe near the corner of 1st and Main that has outdoor seating?"
    }]
  }],
  "tools": [{"googleMaps": {}}],
  "toolConfig": {
    "retrievalConfig": {
      "latLng": {"latitude": 34.050481, "longitude": -118.248526}
    }
  }
}'

Personalizacja na podstawie lokalizacji

Uzyskuj rekomendacje dostosowane do preferencji użytkownika i konkretnego obszaru geograficznego.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "Which family-friendly restaurants near here have the best playground reviews?"

response = client.models.generate_content(
    model='gemini-3.5-flash',
    contents=prompt,
    config=types.GenerateContentConfig(
      tools=[types.Tool(google_maps=types.GoogleMaps())],
      tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
          # Provide the location as context; this is Austin, TX.
          lat_lng=types.LatLng(
              latitude=30.2672, longitude=-97.7431))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if chunks := grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function run() {
  const prompt = "Which family-friendly restaurants near here have the best playground reviews?";

  const response = await ai.models.generateContent({
    model: 'gemini-3.5-flash',
    contents: prompt,
    config: {
      tools: [{googleMaps: {}}],
      toolConfig: {
        retrievalConfig: {
          // Provide the location as context; this is Austin, TX.
          latLng: {
            latitude: 30.2672,
            longitude: -97.7431
          }
        }
      }
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const chunks = response.candidates[0].groundingMetadata?.groundingChunks;
  if (chunks) {
    console.log('-'.repeat(40));
    console.log("Sources:");
    for (const chunk of chunks) {
      if (chunk.maps) {
        console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
      }
    }
  }
}

run();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Which family-friendly restaurants near here have the best playground reviews?"
    }],
  }],
  "tools": [{"googleMaps": {}}],
  "toolConfig": {
    "retrievalConfig": {
      "latLng": {"latitude": 30.2672, "longitude": -97.7431}
    }
  }
}'

Pomoc w planowaniu planu podróży

Generuj plany wielodniowe ze wskazówkami dojazdu i informacjami o różnych lokalizacjach, które idealnie nadają się do aplikacji podróżniczych.

W tym przykładzie token googleMapsWidgetContextToken został poproszony przez włączenie widżetu w narzędziu Map Google. Gdy jest włączony, zwrócony token może służyć do renderowania kontekstowego widżetu Miejsca za pomocą <gmp-places-contextual> component z interfejsu Maps JavaScript API firmy Google.

from google import genai
from google.genai import types

client = genai.Client()

prompt = "Plan a day in San Francisco for me. I want to see the Golden Gate Bridge, visit a museum, and have a nice dinner."

response = client.models.generate_content(
    model='gemini-3.5-flash',
    contents=prompt,
    config=types.GenerateContentConfig(
      tools=[types.Tool(google_maps=types.GoogleMaps(enable_widget=True))],
      tool_config=types.ToolConfig(retrieval_config=types.RetrievalConfig(
          # Provide the location as context, this is in San Francisco.
          lat_lng=types.LatLng(
              latitude=37.78193, longitude=-122.40476))),
    ),
)

print("Generated Response:")
print(response.text)

if grounding := response.candidates[0].grounding_metadata:
  if grounding.grounding_chunks:
    print('-' * 40)
    print("Sources:")
    for chunk in grounding.grounding_chunks:
      print(f'- [{chunk.maps.title}]({chunk.maps.uri})')

  if widget_token := grounding.google_maps_widget_context_token:
    print('-' * 40)
    print(f'<gmp-place-contextual context-token="{widget_token}"></gmp-place-contextual>')

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function run() {
  const prompt = "Plan a day in San Francisco for me. I want to see the Golden Gate Bridge, visit a museum, and have a nice dinner.";

  const response = await ai.models.generateContent({
    model: 'gemini-3.5-flash',
    contents: prompt,
    config: {
      tools: [{googleMaps: {enableWidget: true}}],
      toolConfig: {
        retrievalConfig: {
          // Provide the location as context, this is in San Francisco.
          latLng: {
            latitude: 37.78193,
            longitude: -122.40476
          }
        }
      }
    },
  });

  console.log("Generated Response:");
  console.log(response.text);

  const groundingMetadata = response.candidates[0]?.groundingMetadata;
  if (groundingMetadata) {
    if (groundingMetadata.groundingChunks) {
      console.log('-'.repeat(40));
      console.log("Sources:");
      for (const chunk of groundingMetadata.groundingChunks) {
        if (chunk.maps) {
          console.log(`- [${chunk.maps.title}](${chunk.maps.uri})`);
        }
      }
    }

    if (groundingMetadata.googleMapsWidgetContextToken) {
      console.log('-'.repeat(40));
      document.body.insertAdjacentHTML('beforeend', `<gmp-place-contextual context-token="${groundingMetadata.googleMapsWidgetContextToken}`"></gmp-place-contextual>`);
    }
  }
}

run();

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent' \
  -H 'Content-Type: application/json' \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -d '{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "Plan a day in San Francisco for me. I want to see the Golden Gate Bridge, visit a museum, and have a nice dinner."
    }]
  }],
  "tools": [{"googleMaps": {"enableWidget":"true"}}],
  "toolConfig": {
    "retrievalConfig": {
    "latLng": {"latitude": 37.78193, "longitude": -122.40476}
  }
  }
}'

Gdy widżet zostanie wyrenderowany, będzie wyglądać mniej więcej tak:

Wymagania dotyczące korzystania z usługi

Ta sekcja zawiera opis wymagań dotyczących korzystania z usługi powiązania ze źródłem informacji przy użyciu Map Google.

Informowanie użytkownika o korzystaniu ze źródeł w Mapach Google

W przypadku każdego wyniku powiązanego ze źródłem informacji przy użyciu Map Google otrzymasz źródła w groundingChunks, które obsługują każdą odpowiedź. Zwracane są też te metadane:

• Identyfikator URI danych źródłowych
• tytuł
• Identyfikator

Podczas prezentowania wyników powiązania ze źródłem informacji przy użyciu Map Google musisz określić powiązane źródła w Mapach Google i poinformować użytkowników o tych kwestiach:

• Źródła w Mapach Google muszą znajdować się bezpośrednio po wygenerowanych treściach, które obsługują. Te wygenerowane treści są też nazywane wynikiem powiązanym ze źródłem informacji przy użyciu Map Google.
• Źródła w Mapach Google muszą być widoczne w ramach 1 interakcji użytkownika.

Wyświetlanie źródeł w Mapach Google z linkami do Map Google

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

• Przypisz każde źródło do Map Google zgodnie ze wskazówkami dotyczącymi atrybucji tekstowej w Mapach Google .
• Wyświetl tytuł źródła podany w odpowiedzi.
• Połącz ze źródłem za pomocą uri lub googleMapsUri z odpowiedzi.

Te obrazy pokazują minimalne wymagania dotyczące wyświetlania źródeł i linków do Map Google.

Możesz zwinąć widok źródeł.

Opcjonalnie: możesz rozszerzyć podgląd linku o dodatkowe treści, takie jak:

• Favikona Map Google wstawiona przed atrybucją tekstową Map Google.
• Zdjęcie z adresu URL źródła (og:image).

Więcej informacji o niektórych dostawcach danych do Map Google i ich warunkach licencji znajdziesz w informacjach prawnych dotyczących Map Google i Google Earth.

Wskazówki dotyczące atrybucji tekstowej w Mapach Google

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

• Nie modyfikuj w żaden sposób tekstu Map Google:
  • Nie zmieniaj wielkości liter w Mapach Google.
  • Nie dziel Map Google na kilka wierszy.
  • Nie tłumacz Map Google na inny język.
  • Uniemożliwiaj przeglądarkom tłumaczenie Map Google, używając atrybutu HTML translate="no".
• Stylizuj tekst Map Google zgodnie z opisem w tej tabeli:

Przykładowy kod CSS

Ten kod CSS renderuje Mapy Google 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;
}

Token kontekstu, identyfikator miejsca i identyfikator opinii

Dane z Map Google zawierają token kontekstu, identyfikator miejsca i identyfikator opinii. Możesz buforować, przechowywać i eksportować te dane odpowiedzi:

• googleMapsWidgetContextToken
• placeId
• reviewId

Ograniczenia dotyczące buforowania w Warunkach korzystania z powiązania ze źródłem informacji przy użyciu Map Google nie mają zastosowania.

Zabronione działania i terytoria

Powiązanie ze źródłem informacji przy użyciu Map Google ma dodatkowe ograniczenia dotyczące niektórych treści i działań, aby zapewnić bezpieczeństwo i niezawodność platformy. Oprócz ograniczeń użytkowania określonych w Warunkach:

• Nie będziesz używać powiązania ze źródłem informacji przy użyciu Map Google do działań wysokiego ryzyka, w tym do usług reagowania na sytuacje kryzysowe.
• Nie będziesz rozpowszechniać ani sprzedawać aplikacji, która oferuje powiązanie ze źródłem informacji przy użyciu Map Google, na terytorium objętym zakazem. Więcej informacji znajdziesz w artykule Terytoria objęte zakazem Google Maps Platform. Lista terytoriów objętych zakazem może być okresowo aktualizowana.

Sprawdzone metody

• Podawaj lokalizację użytkownika: aby uzyskać najbardziej trafne i spersonalizowane odpowiedzi, zawsze uwzględniaj user_location (szerokość i długość geograficzną) w konfiguracji googleMapsGrounding, gdy znana jest lokalizacja użytkownika.
• Renderuj kontekstowy widżet Map Google: kontekstowy widżet jest renderowany za pomocą tokena kontekstu googleMapsWidgetContextToken, który jest zwracany w odpowiedzi interfejsu Gemini API i może służyć do renderowania treści wizualnych z Map Google. Więcej informacji o widżecie kontekstowym znajdziesz w przewodniku Google dla programistów w artykule Powiązanie ze źródłem informacji przy użyciu Map Google widżet.
• Informuj użytkowników: wyraźnie informuj użytkowników, że do odpowiadania na ich zapytania używane są dane z Map Google, zwłaszcza gdy narzędzie jest włączone.
• Monitoruj opóźnienie: w przypadku aplikacji konwersacyjnych upewnij się, że opóźnienie P95 w przypadku odpowiedzi powiązanych ze źródłem informacji mieści się w dopuszczalnych progach, aby zapewnić płynne działanie aplikacji.
• Wyłączaj, gdy nie jest potrzebne: powiązanie ze źródłem informacji przy użyciu Map Google jest domyślnie wyłączone. Włączaj je ("tools": [{"googleMaps": {}}]) tylko wtedy, gdy zapytanie ma wyraźny kontekst geograficzny, aby zoptymalizować wydajność i koszty.

Ograniczenia

• Zasięg geograficzny: powiązanie ze źródłem informacji przy użyciu Map Google jest dostępne na całym świecie.
• Obsługa modeli: zapoznaj się z sekcją Obsługiwane modele.
• Dane wejściowe i wyjściowe multimodalne: powiązanie ze źródłem informacji przy użyciu Map Google nie obsługuje obecnie danych wejściowych ani wyjściowych multimodalnych poza tekstem i kontekstowymi widżetami map.
• Stan domyślny: narzędzie powiązania ze źródłem informacji przy użyciu Map Google jest domyślnie wyłączone. Musisz je wyraźnie włączyć w żądaniach do interfejsu API.

Ceny i limity zapytań

Ceny powiązania ze źródłem informacji przy użyciu Map Google są oparte na zapytaniach. Obecna stawka to 25 USD za 1 tys. promptów powiązanych ze źródłem informacji. W ramach bezpłatnego poziomu dostępnych jest też do 500 żądań dziennie. Żądanie jest wliczane do limitu tylko wtedy, gdy prompt zwróci co najmniej 1 wynik powiązany ze źródłem informacji przy użyciu Map Google (czyli wyniki zawierające co najmniej 1 źródło w Mapach Google). Jeśli w ramach 1 żądania do Map Google zostanie wysłanych kilka zapytań, będzie się ono liczyć jako 1 żądanie w ramach limitu zapytań.

Szczegółowe informacje o cenach znajdziesz na stronie Ceny interfejsu Gemini API.

Obsługiwane modele

Powiązanie ze źródłem informacji przy użyciu Map Google jest obsługiwane przez te modele:

Obsługiwane kombinacje narzędzi

Modele Gemini 3 obsługują łączenie wbudowanych narzędzi (takich jak powiązanie ze źródłem informacji przy użyciu Map Google) z narzędziami niestandardowymi (wywoływanie funkcji). Więcej informacji znajdziesz na stronie Kombinacje narzędzi.

Co dalej?

• Wypróbuj powiązanie ze źródłem informacji przy użyciu wyszukiwarki Google w przewodniku Gemini API Cookbook.
• Dowiedz się więcej o innych dostępnych narzędziach.
• Więcej informacji o sprawdzonych metodach dotyczących odpowiedzialnej AI i filtrach bezpieczeństwa interfejsu Gemini API znajdziesz w przewodniku Ustawienia bezpieczeństwa.