Grounding z użyciem Map Google

Grounding z użyciem Map Google łączy możliwości generatywne Gemini z bogatymi, aktualnymi i opartymi na faktach danymi z Map Google. Ta funkcja umożliwia deweloperom łatwe wprowadzanie w aplikacjach funkcji korzystających z informacji o 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ą odpowiednie dla określonej przez użytkownika lokalizacji lub ogólnego obszaru.

  • Dokładne odpowiedzi uwzględniające lokalizację: korzystaj z obszernych i aktualnych danych z Map Google w przypadku zapytań dotyczących konkretnych lokalizacji.
  • Lepsza personalizacja: dostosowuj rekomendacje i informacje na podstawie lokalizacji podanych przez użytkownika.

Rozpocznij

Ten przykład pokazuje, jak zintegrować powiązanie ze źródłami informacji przy użyciu Map Google z aplikacją, aby udzielać dokładnych odpowiedzi uwzględniających lokalizację 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.

Python

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.8-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})')

JavaScript

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

const ai = new GoogleGenAI({});

async function generateContentWithMapsGrounding() {
  const response = await ai.models.generateContent({
    model: "gemini-3.8-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();

REST

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-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 grounding z użyciem 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 powiązania ze źródłem informacji. Gdy zapytanie użytkownika zawiera kontekst geograficzny, model Gemini może wywołać narzędzie Grounding z użyciem Map Google. Model może wtedy generować odpowiedzi na podstawie danych z Map Google dotyczących podanej lokalizacji.

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ązanie ze źródłami informacji przy użyciu Map Google. To narzędzie może opcjonalnie otrzymać współrzędne geograficzne użytkownika (latitude i longitude). Narzędzie to służy do wyszukiwania tekstowego i działa podobnie do wyszukiwania w Mapach. Zapytania lokalne („w pobliżu”) będą korzystać ze współrzędnych, a zapytania konkretne lub nielokalne raczej nie będą uwzględniać lokalizacji.
  3. Pobieranie danych: usługa powiązanie ze źródłami 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 oparte na faktach: Pobrane dane z Map są używane do tworzenia odpowiedzi przez model Gemini, co zapewnia zgodność z prawdą i trafność.
  5. Odpowiedź: model zwraca odpowiedź tekstową, która zawiera cytaty ze źródeł w Mapach Google.

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

Powiązanie ze źródłami informacji przy użyciu Map Google jest idealne w przypadku aplikacji, które wymagają dokładnych, aktualnych i specyficznych dla lokalizacji informacji. Poprawia wrażenia użytkowników, dostarczają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ązanie ze źródłami informacji przy użyciu Map Google należy stosować, gdy aplikacja musi:

  • udzielać pełnych i dokładnych odpowiedzi na pytania dotyczące lokalizacji;
  • tworzyć interaktywne kreatory podróży i przewodniki lokalne;
  • rekomendować ciekawe miejsca na podstawie lokalizacji i preferencji użytkownika, np. restauracje lub sklepy;
  • tworzyć funkcje uwzględniające lokalizację w usługach społecznościowych, handlowych lub dostawy jedzenia.

Powiązanie ze źródłami informacji przy użyciu Map Google sprawdza się w przypadkach użycia, w których kluczowe są bliskość i aktualne dane zgodne z prawdą, np. w przypadku wyszukiwania „najlepszej kawiarni w pobliżu” lub wyznaczania trasy.

Metody i parametry interfejsu API

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

JSON

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

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

JSON

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

Omówienie odpowiedzi groundingu

Gdy odpowiedź zostanie prawidłowo uzasadniona danymi z Map Google, będzie zawierać pole groundingMetadata. Te uporządkowane dane są niezbędne do weryfikowania twierdzeń i tworzenia w aplikacji bogatych cytatów, a także do spełniania wymagań dotyczących korzystania z usługi.

JSON

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

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.

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

Przypadki użycia

Powiązanie ze źródłami informacji przy użyciu Map Google obsługuje różne przypadki użycia uwzględniające lokalizację. Poniższe przykłady pokazują, jak różne prompty i parametry mogą wykorzystać powiązanie ze źródłami informacji przy użyciu Map Google. Informacje w wynikach groundingu z Map Google mogą się różnić od rzeczywistych warunków.

Obsługa pytań dotyczących konkretnego miejsca

Zadawaj szczegółowe pytania dotyczące konkretnego miejsca, aby uzyskać odpowiedzi na podstawie opinii użytkowników Google i innych danych z Map.

Python

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.8-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})')
  ```

Javascript

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.8-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();

REST

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-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.

Python

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.8-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})')

Javascript

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.8-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();

REST

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-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 z trasami i informacjami o różnych lokalizacjach, które idealnie nadają się do aplikacji podróżniczych.

Python

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.8-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 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})')

Javascript

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.8-flash',
    contents: prompt,
    config: {
      tools: [{googleMaps: {}}],
      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})`);
        }
      }
    }
  }
}

run();

REST

curl -X POST 'https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-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": {}}],
  "toolConfig": {
    "retrievalConfig": {
    "latLng": {"latitude": 37.78193, "longitude": -122.40476}
  }
  }
}'

Wymagania dotyczące korzystania z usługi

Ta sekcja zawiera opis wymagań dotyczących korzystania z usługi Grounding z użyciem Map Google.

Informowanie użytkownika o korzystaniu ze źródeł z Map Google

W przypadku każdego wyniku groundingu z 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łami informacji przy użyciu Map Google musisz określić powiązane źródła z Map Google i poinformować użytkowników o tych kwestiach:

  • Źródła z Map Google muszą znajdować się bezpośrednio po wygenerowanych treściach, które obsługują. Te wygenerowane treści są też nazywane wynikiem groundingu z Map Google.
  • Źródła z Map Google muszą być widoczne w ramach jednej interakcji użytkownika.

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

W przypadku każdego źródła w groundingChunks i w 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 z wytycznymi dotyczącymi atrybucji tekstowej Map 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.

Prompt z odpowiedzią i źródłami

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

Prompt ze zwiniętą odpowiedzią i źródłami

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.

Wytyczne dotyczące atrybucji tekstowej Map Google

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

  • 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:
Właściwość Styl
Font family Roboto. Wczytywanie czcionki jest opcjonalne.
Fallback font family Dowolna czcionka bezszeryfowa używana już w Twojej usłudze lub „Sans-Serif”, aby wywołać domyślną czcionkę systemową
Font style Normalna
Font weight 400
Font color Biały, czarny (#1F1F1F) lub szary (#5E5E5E). Zachowaj kontrast z tłem, który jest zgodny z wymaganiami dotyczącymi ułatwień dostępu (4,5:1).
Font size
  • Minimalny rozmiar czcionki: 12sp
  • Maksymalny rozmiar czcionki: 16sp
  • Więcej informacji o jednostkach sp znajdziesz na stronie Rozmiary czcionek w witrynie Material Design.
Spacing Normalna

Przykład CSS

Ten kod CSS renderuje Mapy Google z odpowiednim stylem typograficznym i kolorem na białym lub jasnym tle.

CSS

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

Identyfikator miejsca i identyfikator opinii

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

  • placeId
  • reviewId

Ograniczenia dotyczące zapisywania w pamięci podręcznej w Warunkach korzystania z usługi powiązanie ze źródłami informacji przy użyciu Map Google nie mają zastosowania.

Zabronione działania i terytoria

Powiązanie ze źródłami 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ć groundingu z użyciem 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 grounding z użyciem Map Google, na terytorium objętym zakazem. Więcej informacji znajdziesz na stronie 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.
  • 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 uzasadnionych pozostaje w akceptowalnych granicach, aby zapewnić płynne działanie.
  • Wyłączaj, gdy nie jest potrzebne: Powiązanie ze źródłami informacji przy użyciu Map Google jest domyślnie wyłączone. Aby zoptymalizować wydajność i koszty, włączaj go ("tools": [{"googleMaps": {}}]) tylko wtedy, gdy zapytanie ma wyraźny kontekst geograficzny.

Ograniczenia

  • Zasięg geograficzny: powiązanie ze źródłami 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łami informacji przy użyciu Map Google nie obsługuje obecnie danych wejściowych ani wyjściowych multimodalnych poza tekstem.
  • Stan domyślny: narzędzie powiązanie ze źródłami informacji przy użyciu Map Google jest domyślnie wyłączone. Musisz je wyraźnie włączyć w żądaniach do interfejsu API.

Ceny i ograniczanie liczby żądań

Ceny powiązania ze źródłami informacji przy użyciu Map Google różnią się w zależności od generacji modelu:

  • Modele Gemini 3 i nowsze: Twój projekt jest obciążany opłatą za każde zapytanie wyszukiwania, które model zdecyduje się wykonać. Miesięcznie masz 5000 bezpłatnych zapytań, które są wspólne dla wszystkich modeli Gemini 3 i nowszych, a następnie płacisz 14 USD za 1000 zapytań wyszukiwania. Pojedynczy prompt wyszukiwania (żądanie do interfejsu API wysyłane do modelu) może spowodować, że model wykona wiele zapytań wyszukiwania, aby znaleźć potrzebne informacje. Każde z tych zapytań jest liczone jako płatne użycie narzędzia.
  • Modele Gemini 2.5 i starsze: Twój projekt jest obciążany opłatą za prompt wyszukiwania (25 USD za 1000 promptów z groundingiem). Opłata jest naliczana tylko wtedy, gdy prompt zwróci co najmniej 1 wynik groundingu z Map Google, niezależnie od tego, ile pojedynczych zapytań wyszukiwania model wykonał wewnętrznie, aby uzyskać ten wynik.

Limit zapytań w przypadku powiązania ze źródłami informacji przy użyciu Map Google jest zwykle zgodny z ograniczaniem liczby żądań bazowego modelu Gemini. Szczegółowe informacje o cenach znajdziesz na stronie Ceny interfejsu Gemini API.

Obsługiwane modele

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

Model Powiązanie ze źródłami informacji przy użyciu Map Google
Gemini 4 Argon ✔️
Gemini 3.8 Flash ✔️
Gemini 3.6 Flash ✔️
Gemini 3.5 Flash-Lite ✔️
Gemini 3.1 Pro Preview ✔️
Gemini 3.1 Flash-Lite ✔️
Gemini 3 Flash Preview ✔️
Gemini 2.5 Pro ✔️
Gemini 2.5 Flash ✔️
Gemini 2.5 Flash-Lite ✔️

Obsługiwane kombinacje narzędzi

Aby obsługiwać bardziej złożone przypadki użycia, możesz używać powiązania ze źródłami informacji przy użyciu Map Google z innymi wbudowanymi narzędziami, takimi jak powiązanie ze źródłami informacji przy użyciu wyszukiwarki Google (obsługiwany w modelach Gemini 3.5 Flash-Lite i nowszych). Modele Gemini 3 obsługują też łączenie tych wbudowanych narzędzi z narzędziami niestandardowymi (wywoływanie funkcji). Więcej informacji znajdziesz na stronie Kombinacje narzędzi.

Co dalej?