Wypróbuj nową funkcję wbudowanych narzędzi i wywoływania funkcji oraz powiązania ze źródłem informacji przy użyciu Map Google, która jest teraz obsługiwana w przypadku modeli Gemini 3.

Caching

Zapisywanie kontekstu w pamięci podręcznej umożliwia zapisywanie i ponowne wykorzystywanie wstępnie obliczonych tokenów wejściowych, których chcesz używać wielokrotnie, na przykład podczas zadawania różnych pytań dotyczących tego samego pliku multimedialnego. W zależności od sposobu użycia może to przynieść oszczędności kosztów i czasu. Szczegółowe wprowadzenie znajdziesz w przewodniku Buforowanie kontekstu.

Tworzy zasób CachedContent.

Punkt końcowy

post https://generativelanguage.googleapis.com/v1beta/cachedContents

Treść żądania

Treść żądania zawiera wystąpienie elementu CachedContent.

Pola

contents[] object (Content)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Treść do zapisania w pamięci podręcznej.

tools[] object (Tool)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Lista Tools, których model może użyć do wygenerowania następnej odpowiedzi.

expiration Union type

Określa, kiedy ten zasób wygaśnie. Pole expiration może mieć tylko jedną z tych wartości:

expireTime string (Timestamp format)

Sygnatura czasowa UTC wskazująca, kiedy zasób jest uznawany za nieaktualny. Jest zawsze podawana na wyjściu niezależnie od tego, co zostało wysłane na wejściu.

Korzysta ze standardu RFC 3339, w którym wygenerowane dane wyjściowe są zawsze znormalizowane do formatu Z i zawierają 0, 3, 6 lub 9 cyfr po przecinku. Akceptowane są też przesunięcia inne niż „Z”. Przykłady: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" lub "2014-10-02T15:01:23+05:30".

ttl string (Duration format)

Tylko dane wejściowe. Nowy czas życia tego zasobu (tylko dane wejściowe).

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

displayName string

Opcjonalnie. Niezmienna. Wygenerowana przez użytkownika znacząca nazwa wyświetlana treści w pamięci podręcznej. Maksymalnie 128 znaków Unicode.

model string

Wymagane. Niezmienna. Nazwa Model, która ma być używana w przypadku treści w pamięci podręcznej. Format: models/{model}

systemInstruction object (Content)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Instrukcja systemowa ustawiona przez dewelopera. Obecnie tylko tekst.

toolConfig object (ToolConfig)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Konfiguracja narzędzia Ta konfiguracja jest udostępniana wszystkim narzędziom.

Przykładowe żądanie

Podstawowe

Python

from google import genai
from google.genai import types

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config=types.CreateCachedContentConfig(
        contents=[document],
        system_instruction="You are an expert analyzing transcripts.",
    ),
)
print(cache)

response = client.models.generate_content(
    model=model_name,
    contents="Please summarize this transcript",
    config=types.GenerateContentConfig(cached_content=cache.name),
)
print(response.text)cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
console.log("Cache created:", cache);

const response = await ai.models.generateContent({
  model: modelName,
  contents: "Please summarize this transcript",
  config: { cachedContent: cache.name },
});
console.log("Response text:", response.text);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"), 
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents: contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache created:")
fmt.Println(cache)

// Use the cache for generating content.
response, err := client.Models.GenerateContent(
	ctx,
	modelName,
	genai.Text("Please summarize this transcript"),
	&genai.GenerateContentConfig{
		CachedContent: cache.Name,
	},
)
if err != nil {
	log.Fatal(err)
}
printResponse(response)cache.go

Muszla

wget https://storage.googleapis.com/generativeai-downloads/data/a11.txt
echo '{
  "model": "models/gemini-1.5-flash-001",
  "contents":[
    {
      "parts":[
        {
          "inline_data": {
            "mime_type":"text/plain",
            "data": "'$(base64 $B64FLAGS a11.txt)'"
          }
        }
      ],
    "role": "user"
    }
  ],
  "systemInstruction": {
    "parts": [
      {
        "text": "You are an expert at analyzing transcripts."
      }
    ]
  },
  "ttl": "300s"
}' > request.json

curl -X POST "https://generativelanguage.googleapis.com/v1beta/cachedContents?key=$GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -d @request.json \
 > cache.json

CACHE_NAME=$(cat cache.json | grep '"name":' | cut -d '"' -f 4 | head -n 1)

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-001:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
      "contents": [
        {
          "parts":[{
            "text": "Please summarize this transcript"
          }],
          "role": "user"
        },
      ],
      "cachedContent": "'$CACHE_NAME'"
    }'cache.sh

Nazwa nadawcy

Python

from google import genai
from google.genai import types

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config=types.CreateCachedContentConfig(
        contents=[document],
        system_instruction="You are an expert analyzing transcripts.",
    ),
)
cache_name = cache.name  # Save the name for later

# Later retrieve the cache
cache = client.caches.get(name=cache_name)
response = client.models.generate_content(
    model=model_name,
    contents="Find a lighthearted moment from this transcript",
    config=types.GenerateContentConfig(cached_content=cache.name),
)
print(response.text)cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
const cacheName = cache.name; // Save the name for later

// Later retrieve the cache
const retrievedCache = await ai.caches.get({ name: cacheName });
const response = await ai.models.generateContent({
  model: modelName,
  contents: "Find a lighthearted moment from this transcript",
  config: { cachedContent: retrievedCache.name },
});
console.log("Response text:", response.text);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}
cacheName := cache.Name

// Later retrieve the cache.
cache, err = client.Caches.Get(ctx, cacheName, &genai.GetCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}

response, err := client.Models.GenerateContent(
	ctx,
	modelName,
	genai.Text("Find a lighthearted moment from this transcript"),
	&genai.GenerateContentConfig{
		CachedContent: cache.Name,
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Response from cache (create from name):")
printResponse(response)cache.go

Z czatu

Python

from google import genai
from google.genai import types

client = genai.Client()
model_name = "gemini-1.5-flash-001"
system_instruction = "You are an expert analyzing transcripts."

# Create a chat session with the given system instruction.
chat = client.chats.create(
    model=model_name,
    config=types.GenerateContentConfig(system_instruction=system_instruction),
)
document = client.files.upload(file=media / "a11.txt")

response = chat.send_message(
    message=["Hi, could you summarize this transcript?", document]
)
print("\n\nmodel:  ", response.text)
response = chat.send_message(
    message=["Okay, could you tell me more about the trans-lunar injection"]
)
print("\n\nmodel:  ", response.text)

# To cache the conversation so far, pass the chat history as the list of contents.
cache = client.caches.create(
    model=model_name,
    config={
        "contents": chat.get_history(),
        "system_instruction": system_instruction,
    },
)
# Continue the conversation using the cached content.
chat = client.chats.create(
    model=model_name,
    config=types.GenerateContentConfig(cached_content=cache.name),
)
response = chat.send_message(
    message="I didn't understand that last part, could you explain it in simpler language?"
)
print("\n\nmodel:  ", response.text)cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const modelName = "gemini-1.5-flash-001";
const systemInstruction = "You are an expert analyzing transcripts.";

// Create a chat session with the system instruction.
const chat = ai.chats.create({
  model: modelName,
  config: { systemInstruction: systemInstruction },
});
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);

let response = await chat.sendMessage({
  message: createUserContent([
    "Hi, could you summarize this transcript?",
    createPartFromUri(document.uri, document.mimeType),
  ]),
});
console.log("\n\nmodel:", response.text);

response = await chat.sendMessage({
  message: "Okay, could you tell me more about the trans-lunar injection",
});
console.log("\n\nmodel:", response.text);

// To cache the conversation so far, pass the chat history as the list of contents.
const chatHistory = chat.getHistory();
const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: chatHistory,
    systemInstruction: systemInstruction,
  },
});

// Continue the conversation using the cached content.
const chatWithCache = ai.chats.create({
  model: modelName,
  config: { cachedContent: cache.name },
});
response = await chatWithCache.sendMessage({
  message:
    "I didn't understand that last part, could you explain it in simpler language?",
});
console.log("\n\nmodel:", response.text);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
systemInstruction := "You are an expert analyzing transcripts."

// Create initial chat with a system instruction.
chat, err := client.Chats.Create(ctx, modelName, &genai.GenerateContentConfig{
	SystemInstruction: genai.NewContentFromText(systemInstruction, genai.RoleUser),
}, nil)
if err != nil {
	log.Fatal(err)
}

document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}

// Send first message with the transcript.
parts := make([]genai.Part, 2)
parts[0] = genai.Part{Text: "Hi, could you summarize this transcript?"}
parts[1] = genai.Part{
	FileData: &genai.FileData{
		FileURI :      document.URI,
		MIMEType: document.MIMEType,
	},
}

// Send chat message.
resp, err := chat.SendMessage(ctx, parts...)
if err != nil {
	log.Fatal(err)
}
fmt.Println("\n\nmodel: ", resp.Text())

resp, err = chat.SendMessage(
	ctx, 
	genai.Part{
		Text: "Okay, could you tell me more about the trans-lunar injection",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Println("\n\nmodel: ", resp.Text())

// To cache the conversation so far, pass the chat history as the list of contents.
cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          chat.History(false),
	SystemInstruction: genai.NewContentFromText(systemInstruction, genai.RoleUser),
})
if err != nil {
	log.Fatal(err)
}

// Continue the conversation using the cached history.
chat, err = client.Chats.Create(ctx, modelName, &genai.GenerateContentConfig{
	CachedContent: cache.Name,
}, nil)
if err != nil {
	log.Fatal(err)
}

resp, err = chat.SendMessage(
	ctx, 
	genai.Part{
		Text: "I didn't understand that last part, could you explain it in simpler language?",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Println("\n\nmodel: ", resp.Text())cache.go

Treść odpowiedzi

Jeśli operacja się uda, treść odpowiedzi będzie zawierała nowo utworzoną instancję CachedContent.

Metoda: cachedContents.list

Punkt końcowy
Parametry zapytania
Treść żądania
Treść odpowiedzi
- Zapis JSON

Wyświetla listę CachedContents.

Punkt końcowy

get https://generativelanguage.googleapis.com/v1beta/cachedContents

Parametry zapytania

pageSize integer

Opcjonalnie. Maksymalna liczba treści z pamięci podręcznej do zwrócenia. Usługa może zwrócić mniej niż ta wartość. Jeśli nie podasz tej wartości, zwracana będzie domyślna (poniżej maksymalnej) liczba produktów. Maksymalna wartość to 1000. Wartości powyżej 1000 zostaną przekształcone w 1000.

pageToken string

Opcjonalnie. Token strony otrzymany z poprzedniego wywołania cachedContents.list. Podaj ten token, aby pobrać kolejną stronę.

Podczas paginacji wszystkie inne parametry przekazane do funkcji cachedContents.list muszą być zgodne z wywołaniem, które dostarczyło token strony.

Treść żądania

Treść żądania musi być pusta.

Treść odpowiedzi

Odpowiedź z listą CachedContents.

W przypadku powodzenia treść żądania zawiera dane o następującej strukturze:

Pola

cachedContents[] object (CachedContent)

Lista treści w pamięci podręcznej.

nextPageToken string

Token, który można wysłać jako pageToken, aby pobrać następną stronę. Jeśli pominiesz to pole, nie będzie kolejnych stron.

Zapis JSON
{ "cachedContents": [ { object (`CachedContent`) } ], "nextPageToken": string }

Metoda: cachedContents.get

Punkt końcowy
Parametry ścieżki
Treść żądania
Treść odpowiedzi
Przykładowe żądanie
- Basic

Odczytuje zasób CachedContent.

Punkt końcowy

get https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}

Parametry ścieżki

name string

Wymagane. Nazwa zasobu odnosząca się do wpisu w pamięci podręcznej treści. Format: cachedContents/{id} Ma on postać cachedContents/{cachedcontent}.

Treść żądania

Treść żądania musi być pusta.

Przykładowe żądanie

Python

from google import genai

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config={
        "contents": [document],
        "system_instruction": "You are an expert analyzing transcripts.",
    },
)
print(client.caches.get(name=cache.name))cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
const retrievedCache = await ai.caches.get({ name: cache.name });
console.log("Retrieved Cache:", retrievedCache);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}

cache, err = client.Caches.Get(ctx, cache.Name, &genai.GetCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Retrieved cache:")
fmt.Println(cache)cache.go

Muszla

curl "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"cache.sh

Treść odpowiedzi

W przypadku powodzenia treść odpowiedzi obejmuje wystąpienie elementu CachedContent.

Metoda: cachedContents.patch

Punkt końcowy
Parametry ścieżki
Parametry zapytania
Treść żądania
Treść odpowiedzi
Przykładowe żądanie
- Basic

Aktualizuje zasób CachedContent (można zaktualizować tylko datę wygaśnięcia).

Punkt końcowy

patch https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}

PATCH https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}

Parametry ścieżki

cachedContent.name string

Tylko dane wyjściowe. Identyfikator. Nazwa zasobu odnosząca się do treści w pamięci podręcznej. Format: cachedContents/{id} Ma on postać cachedContents/{cachedcontent}.

Parametry zapytania

updateMask string (FieldMask format)

Lista pól do zaktualizowania.

Jest to lista w pełni kwalifikowanych nazw pól rozdzielona przecinkami. Przykład: "user.displayName,photo".

Treść żądania

Treść żądania zawiera wystąpienie elementu CachedContent.

Pola

expiration Union type

Określa, kiedy ten zasób wygaśnie. Pole expiration może mieć tylko jedną z tych wartości:

expireTime string (Timestamp format)

Sygnatura czasowa UTC wskazująca, kiedy zasób jest uznawany za nieaktualny. Jest zawsze podawana na wyjściu niezależnie od tego, co zostało wysłane na wejściu.

ttl string (Duration format)

Tylko dane wejściowe. Nowy czas życia tego zasobu (tylko dane wejściowe).

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

Przykładowe żądanie

Python

from google import genai
from google.genai import types
import datetime

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config={
        "contents": [document],
        "system_instruction": "You are an expert analyzing transcripts.",
    },
)

# Update the cache's time-to-live (ttl)
ttl = f"{int(datetime.timedelta(hours=2).total_seconds())}s"
client.caches.update(
    name=cache.name, config=types.UpdateCachedContentConfig(ttl=ttl)
)
print(f"After update:\n {cache}")

# Alternatively, update the expire_time directly
# Update the expire_time directly in valid RFC 3339 format (UTC with a "Z" suffix)
expire_time = (
    (
        datetime.datetime.now(datetime.timezone.utc)
        + datetime.timedelta(minutes=15)
    )
    .isoformat()
    .replace("+00:00", "Z")
)
client.caches.update(
    name=cache.name,
    config=types.UpdateCachedContentConfig(expire_time=expire_time),
)cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

let cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});

// Update the cache's time-to-live (ttl)
const ttl = `${2 * 3600}s`; // 2 hours in seconds
cache = await ai.caches.update({
  name: cache.name,
  config: { ttl },
});
console.log("After update (TTL):", cache);

// Alternatively, update the expire_time directly (in RFC 3339 format with a "Z" suffix)
const expireTime = new Date(Date.now() + 15 * 60000)
  .toISOString()
  .replace(/\.\d{3}Z$/, "Z");
cache = await ai.caches.update({
  name: cache.name,
  config: { expireTime: expireTime },
});
console.log("After update (expire_time):", cache);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}

_, err = client.Caches.Delete(ctx, cache.Name, &genai.DeleteCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache deleted:", cache.Name)cache.go

Muszla

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -d '{"ttl": "600s"}'cache.sh

Treść odpowiedzi

W przypadku powodzenia treść odpowiedzi obejmuje wystąpienie elementu CachedContent.

Metoda: cachedContents.delete

Punkt końcowy
Parametry ścieżki
Treść żądania
Treść odpowiedzi
Przykładowe żądanie
- Basic

Usuwa zasób CachedContent.

Punkt końcowy

delete https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}

Parametry ścieżki

name string

Wymagane. Nazwa zasobu odnosząca się do wpisu w pamięci podręcznej treści. Format: cachedContents/{id}. Ma postać cachedContents/{cachedcontent}.

Treść żądania

Treść żądania musi być pusta.

Przykładowe żądanie

Python

from google import genai

client = genai.Client()
document = client.files.upload(file=media / "a11.txt")
model_name = "gemini-1.5-flash-001"

cache = client.caches.create(
    model=model_name,
    config={
        "contents": [document],
        "system_instruction": "You are an expert analyzing transcripts.",
    },
)
client.caches.delete(name=cache.name)cache.py

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const filePath = path.join(media, "a11.txt");
const document = await ai.files.upload({
  file: filePath,
  config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", document.name);
const modelName = "gemini-1.5-flash-001";

const contents = [
  createUserContent(createPartFromUri(document.uri, document.mimeType)),
];

const cache = await ai.caches.create({
  model: modelName,
  config: {
    contents: contents,
    systemInstruction: "You are an expert analyzing transcripts.",
  },
});
await ai.caches.delete({ name: cache.name });
console.log("Cache deleted:", cache.name);cache.js

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

modelName := "gemini-1.5-flash-001"
document, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "a11.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
parts := []*genai.Part{
	genai.NewPartFromURI(document.URI, document.MIMEType),
}
contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{
	Contents:          contents,
	SystemInstruction: genai.NewContentFromText(
		"You are an expert analyzing transcripts.", genai.RoleUser,
	),
})
if err != nil {
	log.Fatal(err)
}

_, err = client.Caches.Delete(ctx, cache.Name, &genai.DeleteCachedContentConfig{})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Cache deleted:", cache.Name)cache.go

Muszla

curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"cache.sh

Treść odpowiedzi

Jeśli operacja się uda, treść odpowiedzi będzie pustym obiektem JSON.

Zasób REST: cachedContents

Zasób: CachedContent
- Zapis JSON
Treść
- Zapis JSON
Część
- Zapis JSON
Blob
- Zapis JSON
FunctionCall
- Zapis JSON
FunctionResponse
- Zapis JSON
FunctionResponsePart
- Zapis JSON
FunctionResponseBlob
- Zapis JSON
Planowanie
FileData
- Zapis JSON
ExecutableCode
- Zapis JSON
Język
CodeExecutionResult
- Zapis JSON
Wynik
ToolCall
- Zapis JSON
ToolType
ToolResponse
- Zapis JSON
VideoMetadata
- Zapis JSON
MediaResolution
- Zapis JSON
Poziom
Narzędzie
- Zapis JSON
FunctionDeclaration
- Zapis JSON
Schemat
- Zapis JSON
Typ
Zachowanie
GoogleSearchRetrieval
- Zapis JSON
DynamicRetrievalConfig
- Zapis JSON
Tryb
CodeExecution
GoogleSearch
- Zapis JSON
Interwał
- Zapis JSON
SearchTypes
- Zapis JSON
WebSearch
ImageSearch
ComputerUse
- Zapis JSON
Środowisko
UrlContext
FileSearch
- Zapis JSON
McpServer
- Zapis JSON
StreamableHttpTransport
- Zapis JSON
GoogleMaps
- Zapis JSON
ToolConfig
- Zapis JSON
FunctionCallingConfig
- Zapis JSON
Tryb
RetrievalConfig
- Zapis JSON
LatLng
- Zapis JSON
UsageMetadata
- Zapis JSON
Metody

Zasób: CachedContent

Treści, które zostały wstępnie przetworzone i mogą być używane w kolejnych żądaniach do GenerativeService.

Treści z pamięci podręcznej mogą być używane tylko z modelem, dla którego zostały utworzone.

Pola

contents[] object (Content)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Treść do zapisania w pamięci podręcznej.

tools[] object (Tool)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Lista Tools, których model może użyć do wygenerowania następnej odpowiedzi.

createTime string (Timestamp format)

Tylko dane wyjściowe. Czas utworzenia wpisu w pamięci podręcznej.

updateTime string (Timestamp format)

Tylko dane wyjściowe. Czas ostatniej aktualizacji wpisu w pamięci podręcznej (w strefie czasowej UTC).

usageMetadata object (UsageMetadata)

Tylko dane wyjściowe. Metadane dotyczące korzystania z treści w pamięci podręcznej.

expiration Union type

Określa, kiedy ten zasób wygaśnie. Pole expiration może mieć tylko jedną z tych wartości:

expireTime string (Timestamp format)

Sygnatura czasowa UTC wskazująca, kiedy zasób jest uznawany za nieaktualny. Jest zawsze podawana na wyjściu niezależnie od tego, co zostało wysłane na wejściu.

ttl string (Duration format)

Tylko dane wejściowe. Nowy czas życia tego zasobu (tylko dane wejściowe).

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

name string

Tylko dane wyjściowe. Identyfikator. Nazwa zasobu odnosząca się do treści w pamięci podręcznej. Format: cachedContents/{id}

displayName string

Opcjonalnie. Niezmienna. Wygenerowana przez użytkownika znacząca nazwa wyświetlana treści w pamięci podręcznej. Maksymalnie 128 znaków Unicode.

model string

Wymagane. Niezmienna. Nazwa Model, która ma być używana w przypadku treści w pamięci podręcznej. Format: models/{model}

systemInstruction object (Content)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Instrukcja systemowa ustawiona przez dewelopera. Obecnie tylko tekst.

toolConfig object (ToolConfig)

Opcjonalnie. Tylko dane wejściowe. Niezmienna. Konfiguracja narzędzia Ta konfiguracja jest udostępniana wszystkim narzędziom.

Zapis JSON

Zapis JSON
{ "contents": [ { object (`Content`) } ], "tools": [ { object (`Tool`) } ], "createTime": string, "updateTime": string, "usageMetadata": { object (`UsageMetadata`) }, // expiration "expireTime": string, "ttl": string // Union type "name": string, "displayName": string, "model": string, "systemInstruction": { object (`Content`) }, "toolConfig": { object (`ToolConfig`) } }

{
  "contents": [
    {
      object (Content)
    }
  ],
  "tools": [
    {
      object (Tool)
    }
  ],
  "createTime": string,
  "updateTime": string,
  "usageMetadata": {
    object (UsageMetadata)
  },

  // expiration
  "expireTime": string,
  "ttl": string
  // Union type
  "name": string,
  "displayName": string,
  "model": string,
  "systemInstruction": {
    object (Content)
  },
  "toolConfig": {
    object (ToolConfig)
  }
}

Treść

Podstawowy typ danych strukturalnych zawierający wieloczęściową treść wiadomości.

Content zawiera pole role, które określa producenta Content, oraz pole parts zawierające dane wieloczęściowe, które zawierają treść tury wiadomości.

Pola

parts[] object (Part)

uporządkowane Parts, które stanowią jedną wiadomość. Poszczególne części mogą mieć różne typy MIME.

role string

Opcjonalnie. Producent treści. Musi to być „user” lub „model”.

Warto ustawić w przypadku rozmów wieloetapowych. W innych przypadkach można pozostawić to pole puste lub nieustawione.

Zapis JSON
{ "parts": [ { object (`Part`) } ], "role": string }

Część

Typ danych zawierający multimedia, które są częścią wieloczęściowej wiadomości Content.

Part to dane powiązane z określonym typem danych. Part może zawierać tylko jeden z akceptowanych typów w Part.data.

Part musi mieć stały typ MIME IANA identyfikujący typ i podtyp multimediów, jeśli pole inlineData jest wypełnione surowymi bajtami.

Pola

thought boolean

Opcjonalnie. Wskazuje, czy część została wygenerowana przez model.

thoughtSignature string (bytes format)

Opcjonalnie. Nieprzezroczysty podpis myśli, który można ponownie wykorzystać w kolejnych żądaniach.

Ciąg zakodowany w formacie Base64.

partMetadata object (Struct format)

Niestandardowe metadane powiązane z elementem. Agenci korzystający z genai.Part jako reprezentacji treści mogą potrzebować śledzenia dodatkowych informacji. Może to być na przykład nazwa pliku lub źródła, z którego pochodzi część, lub sposób multipleksowania wielu strumieni części.

mediaResolution object (MediaResolution)

Opcjonalnie. Rozdzielczość multimediów wejściowych.

data Union type

Pole data może mieć tylko jedną z tych wartości:

text string

Tekst wbudowany.

inlineData object (Blob)

Bajty multimediów w tekście.

functionCall object (FunctionCall)

Prognoza FunctionCall zwrócona przez model, która zawiera ciąg znaków reprezentujący FunctionDeclaration.name z argumentami i ich wartościami.

functionResponse object (FunctionResponse)

Wynik działania funkcji FunctionCall, który zawiera ciąg znaków reprezentujący FunctionDeclaration.name i uporządkowany obiekt JSON zawierający dane wyjściowe funkcji, jest używany jako kontekst dla modelu.

fileData object (FileData)

Dane oparte na identyfikatorze URI.

executableCode object (ExecutableCode)

Kod wygenerowany przez model, który ma zostać wykonany.

codeExecutionResult object (CodeExecutionResult)

Wynik wykonania funkcji ExecutableCode.

toolCall object (ToolCall)

Wywołanie narzędzia po stronie serwera. To pole zostanie zapełnione, gdy model przewidzi wywołanie narzędzia, które powinno zostać wykonane na serwerze. Klient powinien odesłać tę wiadomość do interfejsu API.

toolResponse object (ToolResponse)

Dane wyjściowe wykonania ToolCall po stronie serwera. To pole jest wypełniane przez klienta wynikami wykonania odpowiedniego wywołania ToolCall.

metadata Union type

Określa dodatkowe przetwarzanie wstępne danych. Pole metadata może mieć tylko jedną z tych wartości:

videoMetadata object (VideoMetadata)

Opcjonalnie. metadane filmu, Metadane należy podać tylko wtedy, gdy dane wideo są prezentowane w polu inlineData lub fileData.

Zapis JSON

Zapis JSON
{ "thought": boolean, "thoughtSignature": string, "partMetadata": { object }, "mediaResolution": { object (`MediaResolution`) }, // data "text": string, "inlineData": { object (`Blob`) }, "functionCall": { object (`FunctionCall`) }, "functionResponse": { object (`FunctionResponse`) }, "fileData": { object (`FileData`) }, "executableCode": { object (`ExecutableCode`) }, "codeExecutionResult": { object (`CodeExecutionResult`) }, "toolCall": { object (`ToolCall`) }, "toolResponse": { object (`ToolResponse`) } // Union type // metadata "videoMetadata": { object (`VideoMetadata`) } // Union type }

{
  "thought": boolean,
  "thoughtSignature": string,
  "partMetadata": {
    object
  },
  "mediaResolution": {
    object (MediaResolution)
  },

  // data
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  },
  "toolCall": {
    object (ToolCall)
  },
  "toolResponse": {
    object (ToolResponse)
  }
  // Union type

  // metadata
  "videoMetadata": {
    object (VideoMetadata)
  }
  // Union type
}

Blob

Nieprzetworzone bajty multimediów.

Tekst nie powinien być wysyłany jako surowe bajty. Użyj pola „text”.

Pola

mimeType string

Standardowy typ MIME IANA danych źródłowych. Przykłady: - image/png - image/jpeg Jeśli podano nieobsługiwany typ MIME, zwracany jest błąd. Pełną listę obsługiwanych typów znajdziesz w sekcji Obsługiwane formaty plików.

data string (bytes format)

Nieprzetworzone bajty w przypadku formatów multimedialnych.

Ciąg zakodowany w formacie Base64.

Zapis JSON
{ "mimeType": string, "data": string }

FunctionCall

Prognoza FunctionCall zwrócona przez model, która zawiera ciąg znaków reprezentujący FunctionDeclaration.name z argumentami i ich wartościami.

Pola

id string

Opcjonalnie. Unikalny identyfikator wywołania funkcji. Jeśli to pole jest wypełnione, klient powinien wykonać functionCall i zwrócić odpowiedź z pasującym id.

name string

Wymagane. Nazwa funkcji do wywołania. Musi zawierać litery a–z, A–Z, cyfry 0–9 lub podkreślenia i łączniki. Maksymalna długość to 128 znaków.

args object (Struct format)

Opcjonalnie. Parametry funkcji i wartości w formacie obiektu JSON.

Zapis JSON
{ "id": string, "name": string, "args": { object } }

FunctionResponse

Pola

id string

Opcjonalnie. Identyfikator wywołania funkcji, do którego odnosi się ta odpowiedź. Wypełniane przez klienta w celu dopasowania do odpowiedniego wywołania funkcji id.

name string

Wymagane. Nazwa funkcji do wywołania. Musi zawierać litery a–z, A–Z, cyfry 0–9 lub podkreślenia i łączniki. Maksymalna długość to 128 znaków.

response object (Struct format)

Wymagane. Odpowiedź funkcji w formacie obiektu JSON. Wywołujący mogą używać dowolnych kluczy, które pasują do składni funkcji, aby zwracać dane wyjściowe funkcji, np. „output”, „result” itp. W szczególności, jeśli wywołanie funkcji nie powiodło się, odpowiedź może zawierać klucz „error”, aby zwrócić modelowi szczegóły błędu.

parts[] object (FunctionResponsePart)

Opcjonalnie. Uporządkowane Parts, które stanowią odpowiedź funkcji. Poszczególne części mogą mieć różne typy MIME IANA.

willContinue boolean

Opcjonalnie. Sygnalizuje, że wywołanie funkcji jest kontynuowane i zostaną zwrócone kolejne odpowiedzi, co spowoduje przekształcenie wywołania funkcji w generator. Dotyczy tylko wywołań funkcji NON_BLOCKING, w innych przypadkach jest ignorowana. Jeśli ma wartość Fałsz, przyszłe odpowiedzi nie będą brane pod uwagę. Można zwrócić pusty obiekt response z wartością willContinue=False, aby zasygnalizować zakończenie wywołania funkcji. Może to nadal powodować generowanie modelu. Aby uniknąć wywołania generowania i zakończyć wywołanie funkcji, ustaw dodatkowo scheduling na SILENT.

scheduling enum (Scheduling)

Opcjonalnie. Określa, jak odpowiedź powinna być zaplanowana w rozmowie. Dotyczy tylko wywołań funkcji NON_BLOCKING. W innych przypadkach jest ignorowana. Domyślna wartość to WHEN_IDLE.

Zapis JSON
{ "id": string, "name": string, "response": { object }, "parts": [ { object (`FunctionResponsePart`) } ], "willContinue": boolean, "scheduling": enum (`Scheduling`) }

FunctionResponsePart

Typ danych zawierający multimedia, które są częścią wiadomości FunctionResponse.

FunctionResponsePart to dane powiązane z określonym typem danych. FunctionResponsePart może zawierać tylko jeden z akceptowanych typów w FunctionResponsePart.data.

FunctionResponsePart musi mieć stały typ MIME IANA identyfikujący typ i podtyp multimediów, jeśli pole inlineData jest wypełnione surowymi bajtami.

Pola

data Union type

Dane z części odpowiedzi funkcji. Pole data może mieć tylko jedną z tych wartości:

inlineData object (FunctionResponseBlob)

Bajty multimediów w tekście.

Zapis JSON
{ // data "inlineData": { object (`FunctionResponseBlob`) } // Union type }

FunctionResponseBlob

Surowe bajty multimediów w odpowiedzi funkcji.

Tekst nie powinien być wysyłany jako surowe bajty. Użyj pola „FunctionResponse.response”.

Pola

mimeType string

data string (bytes format)

Nieprzetworzone bajty w przypadku formatów multimedialnych.

Ciąg zakodowany w formacie Base64.

Zapis JSON
{ "mimeType": string, "data": string }

Harmonogram

Określa, jak odpowiedź powinna być zaplanowana w rozmowie.

Wartości w polu enum
`SCHEDULING_UNSPECIFIED`	Ta wartość nie jest używana.
`SILENT`	Dodaj wynik tylko do kontekstu rozmowy. Nie przerywaj ani nie wywołuj generowania.
`WHEN_IDLE`	Dodaj wynik do kontekstu rozmowy i poproś o wygenerowanie danych wyjściowych bez przerywania bieżącego generowania.
`INTERRUPT`	Dodaj wynik do kontekstu rozmowy, przerwij bieżące generowanie i poproś o wygenerowanie danych wyjściowych.

FileData

Dane oparte na identyfikatorze URI.

Pola

mimeType string

Opcjonalnie. Standardowy typ MIME danych źródłowych zgodny z IANA.

fileUri string

Wymagane. URI.

Zapis JSON


{
  "mimeType": string,
  "fileUri": string
}

Zapis JSON
{ "mimeType": string, "fileUri": string }

ExecutableCode

Kod wygenerowany przez model, który ma zostać wykonany, a wynik zwrócony do modelu.

Generowany tylko podczas korzystania z narzędzia CodeExecution, w którym kod jest wykonywany automatycznie, a także generowany jest odpowiedni CodeExecutionResult.

Pola

id string

Opcjonalnie. Unikalny identyfikator części ExecutableCode. Serwer zwraca CodeExecutionResult z pasującym id.

language enum (Language)

Wymagane. Język programowania code.

code string

Wymagane. Kod do wykonania.

Zapis JSON
{ "id": string, "language": enum (`Language`), "code": string }

Język

Obsługiwane języki programowania dla wygenerowanego kodu.

Wartości w polu enum
`LANGUAGE_UNSPECIFIED`	Nieokreślony język. Nie należy używać tej wartości.
`PYTHON`	Python >= 3.10 z dostępnymi bibliotekami numpy i simpy. Domyślnym językiem jest Python.

CodeExecutionResult

Wynik wykonania funkcji ExecutableCode.

Generowane tylko wtedy, gdy używane jest narzędzie CodeExecution.

Pola

id string

Opcjonalnie. Identyfikator części ExecutableCode, której dotyczy ten wynik. Wypełnione tylko wtedy, gdy odpowiedni element ExecutableCode ma identyfikator.

outcome enum (Outcome)

Wymagane. Wynik wykonania kodu.

output string

Opcjonalnie. Zawiera stdout, gdy wykonanie kodu zakończy się powodzeniem, a w innych przypadkach stderr lub inny opis.

Zapis JSON
{ "id": string, "outcome": enum (`Outcome`), "output": string }

Wynik

Wyliczenie możliwych wyników wykonania kodu.

Wartości w polu enum
`OUTCOME_UNSPECIFIED`	Stan nieokreślony. Nie należy używać tej wartości.
`OUTCOME_OK`	Kod został wykonany. `output` zawiera standardowe wyjście, jeśli takie istnieje.
`OUTCOME_FAILED`	Nie udało się wykonać kodu. `output` zawiera stderr i stdout, jeśli występują.
`OUTCOME_DEADLINE_EXCEEDED`	Wykonanie kodu trwało zbyt długo i zostało anulowane. Może występować częściowy element `output`.

ToolCall

Przewidywana wartość ToolCall po stronie serwera zwrócona przez model. Ta wiadomość zawiera informacje o narzędziu, które model chce wywołać. Klient NIE powinien wykonywać tego ToolCall. Zamiast tego klient powinien przekazać ten obiekt ToolCall z powrotem do interfejsu API w kolejnej turze w ramach wiadomości Content wraz z odpowiednim parametrem ToolResponse.

Pola

id string

Opcjonalnie. Unikalny identyfikator wywołania narzędzia. Serwer zwraca odpowiedź narzędzia z pasującym id.

toolType enum (ToolType)

Wymagane. Typ wywołanego narzędzia.

args object (Struct format)

Opcjonalnie. Argumenty wywołania narzędzia. Przykład: {"arg1" : "value1", "arg2" : "value2" , ...}

Zapis JSON
{ "id": string, "toolType": enum (`ToolType`), "args": { object } }

ToolType

Typ narzędzia w wywołaniu funkcji.

Wartości w polu enum
`TOOL_TYPE_UNSPECIFIED`	Nieokreślony typ narzędzia.
`GOOGLE_SEARCH_WEB`	Narzędzie wyszukiwarki Google, które jest mapowane na Tool.google_search.search_types.web_search.
`GOOGLE_SEARCH_IMAGE`	Narzędzie do wyszukiwania obrazów, które odpowiada Tool.google_search.search_types.image_search.
`URL_CONTEXT`	Narzędzie kontekstu adresu URL, które odpowiada Tool.url_context.
`GOOGLE_MAPS`	Narzędzie Mapy Google, które jest mapowane na Tool.google_maps.
`FILE_SEARCH`	Narzędzie do wyszukiwania plików, które odpowiada Tool.file_search.

ToolResponse

Dane wyjściowe wykonania ToolCall po stronie serwera. Ta wiadomość zawiera wyniki wywołania narzędzia zainicjowanego przez ToolCall z modelu. Klient powinien przekazać ten parametr ToolResponse z powrotem do interfejsu API w kolejnej turze w ramach wiadomości Content wraz z odpowiednim parametrem ToolCall.

Pola

id string

Opcjonalnie. Identyfikator wywołania narzędzia, którego dotyczy ta odpowiedź.

toolType enum (ToolType)

Wymagane. Typ wywołanego narzędzia, który pasuje do wartości toolType w odpowiednim polu ToolCall.

response object (Struct format)

Opcjonalnie. Odpowiedź narzędzia.

Zapis JSON
{ "id": string, "toolType": enum (`ToolType`), "response": { object } }

VideoMetadata

Wycofana: zamiast niej używaj zasady GenerateContentRequest.processing_options. Metadane opisują wejściowe treści wideo.

Pola

startOffset string (Duration format)

Opcjonalnie. Przesunięcie początku filmu.

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

endOffset string (Duration format)

Opcjonalnie. Przesunięcie końca filmu.

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

fps number

Opcjonalnie. Liczba klatek na sekundę filmu przesłanego do modelu. Jeśli nie podasz żadnej opcji, domyślna wartość to 1.0. Zakres klatek na sekundę to (0,0, 24,0].

Zapis JSON
{ "startOffset": string, "endOffset": string, "fps": number }

MediaResolution

Rozdzielczość multimediów na potrzeby tokenizacji.

Pola

value Union type

Poziom rozdzielczości multimediów. Pole value może mieć tylko jedną z tych wartości:

level enum (Level)

Jakość tokenizacji używana w przypadku danego medium. w sprawie pomocy dotyczącej Gemini API.

Zapis JSON
{ // value "level": enum (`Level`) // Union type }

Poziom

Poziom rozdzielczości multimediów.

Wartości w polu enum
`MEDIA_RESOLUTION_UNSPECIFIED`	Rozdzielczość multimediów nie została ustawiona.
`MEDIA_RESOLUTION_LOW`	Rozdzielczość multimediów jest ustawiona na niską.
`MEDIA_RESOLUTION_MEDIUM`	Rozdzielczość multimediów ustawiona na średnią.
`MEDIA_RESOLUTION_HIGH`	Rozdzielczość multimediów ustawiona na wysoką.
`MEDIA_RESOLUTION_ULTRA_HIGH`	Rozdzielczość multimediów ustawiona na ultrawysoką.

Narzędzie

Szczegóły narzędzia, których model może użyć do wygenerowania odpowiedzi.

Tool to fragment kodu, który umożliwia systemowi interakcję z systemami zewnętrznymi w celu wykonania działania lub zestawu działań wykraczających poza wiedzę i zakres modelu.

Następny identyfikator: 15

Pola

functionDeclarations[] object (FunctionDeclaration)

Opcjonalnie. Lista FunctionDeclarations dostępnych dla modelu, których można używać do wywoływania funkcji.

Model lub system nie wykonuje funkcji. Zamiast tego zdefiniowana funkcja może być zwracana jako FunctionCall z argumentami po stronie klienta do wykonania. Model może zdecydować się na wywołanie podzbioru tych funkcji, wypełniając w odpowiedzi pole FunctionCall. Kolejna tura rozmowy może zawierać FunctionResponse z kontekstem generowania Content.role „function” dla kolejnej tury modelu.

googleSearchRetrieval object (GoogleSearchRetrieval)

Opcjonalnie. Narzędzie do wyszukiwania obsługiwane przez wyszukiwarkę Google.

codeExecution object (CodeExecution)

Opcjonalnie. Umożliwia modelowi wykonywanie kodu w ramach generowania.

googleSearch object (GoogleSearch)

Opcjonalnie. Typ narzędzia GoogleSearch. Narzędzie do obsługi wyszukiwarki Google w Modelu. Technologia Google.

computerUse object (ComputerUse)

Opcjonalnie. Narzędzie umożliwiające modelowi bezpośrednią interakcję z komputerem. Jeśli ta opcja jest włączona, automatycznie wypełnia deklaracje funkcji dotyczące korzystania z komputera.

urlContext object (UrlContext)

Opcjonalnie. Narzędzie do pobierania kontekstu adresu URL.

fileSearch object (FileSearch)

Opcjonalnie. Typ narzędzia FileSearch. Narzędzie do pobierania wiedzy z korpusów wyszukiwania semantycznego.

mcpServers[] object (McpServer)

Opcjonalnie. Serwery MCP, z którymi można się połączyć.

googleMaps object (GoogleMaps)

Opcjonalnie. Narzędzie, które umożliwia oparcie odpowiedzi modelu na faktach z kontekstem geoprzestrzennym związanym z zapytaniem użytkownika.

Zapis JSON

Zapis JSON
{ "functionDeclarations": [ { object (`FunctionDeclaration`) } ], "googleSearchRetrieval": { object (`GoogleSearchRetrieval`) }, "codeExecution": { object (`CodeExecution`) }, "googleSearch": { object (`GoogleSearch`) }, "computerUse": { object (`ComputerUse`) }, "urlContext": { object (`UrlContext`) }, "fileSearch": { object (`FileSearch`) }, "mcpServers": [ { object (`McpServer`) } ], "googleMaps": { object (`GoogleMaps`) } }

{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "googleSearchRetrieval": {
    object (GoogleSearchRetrieval)
  },
  "codeExecution": {
    object (CodeExecution)
  },
  "googleSearch": {
    object (GoogleSearch)
  },
  "computerUse": {
    object (ComputerUse)
  },
  "urlContext": {
    object (UrlContext)
  },
  "fileSearch": {
    object (FileSearch)
  },
  "mcpServers": [
    {
      object (McpServer)
    }
  ],
  "googleMaps": {
    object (GoogleMaps)
  }
}

FunctionDeclaration

Ustrukturyzowana reprezentacja deklaracji funkcji zgodnie ze specyfikacją OpenAPI 3.03. Deklaracja zawiera nazwę funkcji i parametry. FunctionDeclaration to reprezentacja bloku kodu, który może być używany przez model jako Tool i wykonywany przez klienta.

Pola

name string

Wymagane. Nazwa funkcji. Musi zawierać litery (a–z, A–Z), cyfry (0–9) lub podkreślenia, dwukropki, kropki i myślniki. Maksymalna długość to 128 znaków.

description string

Wymagane. Krótki opis funkcji.

behavior enum (Behavior)

Opcjonalnie. Określa zachowanie funkcji. Obecnie obsługiwane tylko przez metodę BidiGenerateContent.

parameters object (Schema)

Opcjonalnie. Opisuje parametry tej funkcji. Odpowiada kluczowi ciągu obiektu parametru Open API 3.03: nazwie parametru. W nazwach parametrów jest rozróżniana wielkość liter. Wartość schematu: schemat definiujący typ używany w parametrze.

parametersJsonSchema value (Value format)

Opcjonalnie. Opisuje parametry funkcji w formacie schematu JSON. Schemat musi opisywać obiekt, którego właściwości są parametrami funkcji. Na przykład:

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" }
  },
  "additionalProperties": false,
  "required": ["name", "age"],
  "propertyOrdering": ["name", "age"]
}

To pole wyklucza się z polem parameters.

response object (Schema)

Opcjonalnie. Opisuje dane wyjściowe tej funkcji w formacie schematu JSON. Odpowiada obiektowi odpowiedzi Open API 3.03. Schemat określa typ używany w wartości odpowiedzi funkcji.

responseJsonSchema value (Value format)

Opcjonalnie. Opisuje dane wyjściowe tej funkcji w formacie schematu JSON. Wartość określona przez schemat jest wartością odpowiedzi funkcji.

To pole wyklucza się z polem response.

Zapis JSON

Zapis JSON
{ "name": string, "description": string, "behavior": enum (`Behavior`), "parameters": { object (`Schema`) }, "parametersJsonSchema": value, "response": { object (`Schema`) }, "responseJsonSchema": value }

{
  "name": string,
  "description": string,
  "behavior": enum (Behavior),
  "parameters": {
    object (Schema)
  },
  "parametersJsonSchema": value,
  "response": {
    object (Schema)
  },
  "responseJsonSchema": value
}

Schemat

Obiekt Schema umożliwia definiowanie typów danych wejściowych i wyjściowych. Mogą to być obiekty, ale też typy proste i tablice. Reprezentuje wybrany podzbiór obiektu schematu OpenAPI 3.0.

Pola

type enum (Type)

Wymagane. Typ danych.

format string

Opcjonalnie. Format danych. Dozwolona jest dowolna wartość, ale większość z nich nie wywołuje żadnych specjalnych funkcji.

title string

Opcjonalnie. Tytuł schematu.

description string

Opcjonalnie. Krótki opis parametru. Może zawierać przykłady użycia. Opis parametru może być sformatowany w Markdown.

nullable boolean

Opcjonalnie. Wskazuje, czy wartość może być pusta.

enum[] string

Opcjonalnie. Możliwe wartości elementu Type.STRING w formacie wyliczeniowym. Na przykład możemy zdefiniować wyliczenie Direction w ten sposób : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]}

maxItems string (int64 format)

Opcjonalnie. Maksymalna liczba elementów w przypadku Type.ARRAY.

minItems string (int64 format)

Opcjonalnie. Minimalna liczba elementów dla Type.ARRAY.

properties map (key: string, value: object (Schema))

Opcjonalnie. Właściwości Type.OBJECT.

Obiekt zawierający listę par "key": value. Przykład: { "name": "wrench", "mass": "1.3kg", "count": "3" }

required[] string

Opcjonalnie. Wymagane właściwości Type.OBJECT.

minProperties string (int64 format)

Opcjonalnie. Minimalna liczba właściwości dla typu OBJECT.

maxProperties string (int64 format)

Opcjonalnie. Maksymalna liczba właściwości dla Type.OBJECT.

minLength string (int64 format)

Opcjonalnie. POLA SCHEMATU DLA TYPU STRING Minimalna długość typu STRING

maxLength string (int64 format)

Opcjonalnie. Maksymalna długość Type.STRING

pattern string

Opcjonalnie. Wzorzec typu STRING, który ogranicza ciąg znaków do wyrażenia regularnego.

example value (Value format)

Opcjonalnie. Przykład obiektu. Wypełniane tylko wtedy, gdy obiekt jest elementem głównym.

anyOf[] object (Schema)

Opcjonalnie. Wartość powinna być weryfikowana na podstawie dowolnego (co najmniej jednego) podschematu na liście.

propertyOrdering[] string

Opcjonalnie. Kolejność właściwości. Nie jest to standardowe pole w specyfikacji otwartego interfejsu API. Służy do określania kolejności właściwości w odpowiedzi.

default value (Value format)

Opcjonalnie. Wartość domyślna pola. Zgodnie ze schematem JSON to pole jest przeznaczone dla generatorów dokumentacji i nie wpływa na weryfikację. Dlatego jest ono uwzględniane i ignorowane, aby deweloperzy wysyłający schematy z polem default nie otrzymywali błędów związanych z nieznanym polem.

items object (Schema)

Opcjonalnie. Schemat elementów typu Type.ARRAY.

minimum number

Opcjonalnie. POLA SCHEMATU DLA TYPÓW INTEGER I NUMBER Minimalna wartość typu Type.INTEGER i Type.NUMBER

maximum number

Opcjonalnie. Maksymalna wartość typów Type.INTEGER i Type.NUMBER

Zapis JSON

Zapis JSON
{ "type": enum (`Type`), "format": string, "title": string, "description": string, "nullable": boolean, "enum": [ string ], "maxItems": string, "minItems": string, "properties": { string: { object (`Schema`) }, ... }, "required": [ string ], "minProperties": string, "maxProperties": string, "minLength": string, "maxLength": string, "pattern": string, "example": value, "anyOf": [ { object (`Schema`) } ], "propertyOrdering": [ string ], "default": value, "items": { object (`Schema`) }, "minimum": number, "maximum": number }

{
  "type": enum (Type),
  "format": string,
  "title": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "maxItems": string,
  "minItems": string,
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "minProperties": string,
  "maxProperties": string,
  "minLength": string,
  "maxLength": string,
  "pattern": string,
  "example": value,
  "anyOf": [
    {
      object (Schema)
    }
  ],
  "propertyOrdering": [
    string
  ],
  "default": value,
  "items": {
    object (Schema)
  },
  "minimum": number,
  "maximum": number
}

Typ

Typ zawiera listę typów danych OpenAPI zgodnie z definicją na stronie https://spec.openapis.org/oas/v3.0.3#data-types.

Wartości w polu enum
`TYPE_UNSPECIFIED`	Nie określono, nie należy używać.
`STRING`	Typ ciągu znaków.
`NUMBER`	Typ numeru.
`INTEGER`	Typ liczby całkowitej.
`BOOLEAN`	Typ logiczny.
`ARRAY`	Typ tablicy.
`OBJECT`	Typ obiektu.
`NULL`	Typ null.

Zachowanie

Określa zachowanie funkcji. Domyślna wartość to BLOCKING.

Wartości w polu enum
`UNSPECIFIED`	Ta wartość nie jest używana.
`BLOCKING`	Jeśli ta opcja jest ustawiona, system będzie czekać na odpowiedź funkcji przed kontynuowaniem rozmowy.
`NON_BLOCKING`	Jeśli ta opcja jest ustawiona, system nie będzie czekać na odpowiedź funkcji. Zamiast tego będzie próbować obsługiwać odpowiedzi funkcji, gdy staną się dostępne, przy jednoczesnym zachowaniu rozmowy między użytkownikiem a modelem.

GoogleSearchRetrieval

Narzędzie do pobierania publicznych danych z internetu na potrzeby ugruntowania, obsługiwane przez Google.

Pola

dynamicRetrievalConfig object (DynamicRetrievalConfig)

Określa konfigurację dynamicznego pobierania dla danego źródła.

Zapis JSON
{ "dynamicRetrievalConfig": { object (`DynamicRetrievalConfig`) } }

DynamicRetrievalConfig

Opisuje opcje dostosowywania dynamicznego pobierania.

Pola

mode enum (Mode)

Tryb predyktora, który ma być używany w dynamicznym pobieraniu.

dynamicThreshold number

Próg, który ma być używany w dynamicznym pobieraniu. Jeśli nie zostanie ustawiona, używana jest domyślna wartość systemowa.

Zapis JSON
{ "mode": enum (`Mode`), "dynamicThreshold": number }

Tryb

Tryb predyktora, który ma być używany w dynamicznym pobieraniu.

Wartości w polu enum
`MODE_UNSPECIFIED`	Zawsze wywołuj pobieranie.
`MODE_DYNAMIC`	Pobieranie jest uruchamiane tylko wtedy, gdy system uzna to za konieczne.

CodeExecution

Ten typ nie ma pól.

Narzędzie, które wykonuje kod wygenerowany przez model i automatycznie zwraca wynik do modelu.

Zobacz też ExecutableCode i CodeExecutionResult, które są generowane tylko podczas korzystania z tego narzędzia.

GoogleSearch

Typ narzędzia GoogleSearch. Narzędzie do obsługi wyszukiwarki Google w Modelu. Technologia Google.

Pola

timeRangeFilter object (Interval)

Opcjonalnie. Filtrowanie wyników wyszukiwania według określonego zakresu czasowego. Jeśli klienci ustawią godzinę rozpoczęcia, muszą też ustawić godzinę zakończenia (i odwrotnie).

searchTypes object (SearchTypes)

Opcjonalnie. Zestaw typów wyszukiwania do włączenia. Jeśli nie zostanie ustawiona, wyszukiwanie w internecie jest domyślnie włączone.

Zapis JSON
{ "timeRangeFilter": { object (`Interval`) }, "searchTypes": { object (`SearchTypes`) } }

Interwał

Reprezentuje przedział czasu zakodowany jako sygnatura czasowa rozpoczęcia (włącznie) i sygnatura czasowa zakończenia (wyłącznie).

Wartość początkowa musi być mniejsza lub równa wartości końcowej. Gdy czas rozpoczęcia jest równy czasowi zakończenia, przedział czasu jest pusty (nie pasuje do żadnego czasu). Jeśli nie podasz ani początku, ani końca, przedział będzie pasować do dowolnego czasu.

Pola

startTime string (Timestamp format)

Opcjonalnie. Początek przedziału (włącznie).

Jeśli została określona, sygnatura czasowa pasująca do tego przedziału musi być taka sama jak data rozpoczęcia lub późniejsza.

endTime string (Timestamp format)

Opcjonalne. Koniec przedziału (wyłącznie).

Jeśli jest określona, sygnatura czasowa pasująca do tego przedziału musi być wcześniejsza niż czas zakończenia.

Zapis JSON
{ "startTime": string, "endTime": string }

SearchTypes

Różne typy wyszukiwania, które można włączyć w narzędziu GoogleSearch.

Pola

webSearch object (WebSearch)

Opcjonalnie. Umożliwia wyszukiwanie w internecie. Zwracane są tylko wyniki tekstowe.

imageSearch object (ImageSearch)

Opcjonalnie. Umożliwia wyszukiwanie obrazów. Zwracane są bajty obrazu.

Zapis JSON
{ "webSearch": { object (`WebSearch`) }, "imageSearch": { object (`ImageSearch`) } }

WebSearch

Ten typ nie ma pól.

Standardowe wyszukiwanie w internecie na potrzeby oparcia na faktach i powiązanych konfiguracji.

ImageSearch

Ten typ nie ma pól.

Wyszukiwanie obrazów w celu oparcia na faktach i powiązanych konfiguracji.

ComputerUse

Typ narzędzia Computer Use.

Pola

environment enum (Environment)

Wymagane. Środowisko, w którym wykonywana jest operacja.

excludedPredefinedFunctions[] string

Opcjonalnie. Domyślnie predefiniowane funkcje są uwzględniane w ostatecznym wywołaniu modelu. Niektóre z nich można wyraźnie wykluczyć z automatycznego uwzględniania. Może to służyć 2 celom: używanie bardziej ograniczonej lub innej przestrzeni działań; 2. Ulepszanie definicji i instrukcji predefiniowanych funkcji.

Zapis JSON
{ "environment": enum (`Environment`), "excludedPredefinedFunctions": [ string ] }

Środowisko

Reprezentuje środowisko, w którym działa usługa, np. przeglądarkę internetową.

Wartości w polu enum
`ENVIRONMENT_UNSPECIFIED`	Wartość domyślna to browser.
`ENVIRONMENT_BROWSER`	Działa w przeglądarce.

UrlContext

Ten typ nie ma pól.

Narzędzie do pobierania kontekstu adresu URL.

FileSearch

Narzędzie FileSearch, które pobiera wiedzę z korpusów wyszukiwania semantycznego. Pliki są importowane do korpusów wyszukiwania semantycznego za pomocą interfejsu ImportFile API.

Pola

fileSearchStoreNames[] string

Wymagane. Nazwy usług fileSearchStores, z których mają być pobierane dane. Przykład: fileSearchStores/my-file-search-store-123

metadataFilter string

Opcjonalnie. Filtr metadanych, który ma być stosowany do dokumentów i fragmentów pobranych semantycznie.

topK integer

Opcjonalnie. Liczba fragmentów do pobrania w ramach wyszukiwania semantycznego.

Zapis JSON
{ "fileSearchStoreNames": [ string ], "metadataFilter": string, "topK": integer }

McpServer

MCPServer to serwer, który może być wywoływany przez model w celu wykonywania działań. Jest to serwer, który implementuje protokół MCP. Następny identyfikator: 5

Pola

name string

Nazwa serwera MCP.

transport Union type

Transport używany do łączenia się z serwerem MCPServer. Pole transport może mieć tylko jedną z tych wartości:

streamableHttpTransport object (StreamableHttpTransport)

Transport, który może przesyłać strumieniowo żądania i odpowiedzi HTTP.

Zapis JSON
{ "name": string, // transport "streamableHttpTransport": { object (`StreamableHttpTransport`) } // Union type }

StreamableHttpTransport

Transport, który może przesyłać strumieniowo żądania i odpowiedzi HTTP. Następny identyfikator: 6

Pola

url string

Pełny adres URL punktu końcowego MCPServer. Przykład: „https://api.example.com/mcp”

headers map (key: string, value: string)

Opcjonalnie: pola nagłówków uwierzytelniania, limitów czasu itp. (w razie potrzeby).

Obiekt zawierający listę par "key": value. Przykład: { "name": "wrench", "mass": "1.3kg", "count": "3" }

timeout string (Duration format)

Limit czasu HTTP dla zwykłych operacji.

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

sseReadTimeout string (Duration format)

Limit czasu operacji odczytu SSE.

Czas trwania w sekundach z maksymalnie 9 miejscami po przecinku, zakończony znakiem „s”. Przykład: "3.5s".

terminateOnClose boolean

Określa, czy zamknąć sesję klienta po zamknięciu transportu.

Zapis JSON
{ "url": string, "headers": { string: string, ... }, "timeout": string, "sseReadTimeout": string, "terminateOnClose": boolean }

GoogleMaps

Narzędzie Google Maps, które zapewnia kontekst geoprzestrzenny dla zapytania użytkownika.

Pola

enableWidget boolean

Opcjonalnie. Określa, czy w odpowiedzi w polu GroundingMetadata ma być zwracany token kontekstu widżetu. Deweloperzy mogą używać tokena kontekstu widżetu do renderowania widżetu Map Google z kontekstem geoprzestrzennym związanym z miejscami, do których odwołuje się model w odpowiedzi.

Zapis JSON
{ "enableWidget": boolean }

ToolConfig

Konfiguracja narzędzia zawierająca parametry określające użycie Tool w żądaniu.

Pola

functionCallingConfig object (FunctionCallingConfig)

Opcjonalnie. Konfiguracja wywoływania funkcji.

retrievalConfig object (RetrievalConfig)

Opcjonalnie. Konfiguracja pobierania.

includeServerSideToolInvocations boolean

Opcjonalnie. Jeśli wartość to „true”, odpowiedź interfejsu API będzie zawierać wywołania narzędzi po stronie serwera i odpowiedzi w wiadomości Content. Umożliwia to klientom obserwowanie interakcji narzędzia z serwerem.

Zapis JSON
{ "functionCallingConfig": { object (`FunctionCallingConfig`) }, "retrievalConfig": { object (`RetrievalConfig`) }, "includeServerSideToolInvocations": boolean }

FunctionCallingConfig

Konfiguracja określająca działanie wywoływania funkcji.

Pola

mode enum (Mode)

Opcjonalnie. Określa tryb, w którym ma być wykonywane wywoływanie funkcji. Jeśli nie zostanie określona, wartością domyślną będzie AUTO.

allowedFunctionNames[] string

Opcjonalnie. Zbiór nazw funkcji, które po podaniu ograniczają funkcje, które model będzie wywoływać.

Tę wartość należy ustawić tylko wtedy, gdy tryb to ANY lub VALIDATED. Nazwy funkcji powinny być zgodne z [FunctionDeclaration.name]. Gdy ta opcja jest ustawiona, model będzie prognozować wywołanie funkcji tylko na podstawie dozwolonych nazw funkcji.

Zapis JSON
{ "mode": enum (`Mode`), "allowedFunctionNames": [ string ] }

Tryb

Określa sposób wykonywania wywołań funkcji przez zdefiniowanie trybu wykonywania.

Wartości w polu enum
`MODE_UNSPECIFIED`	Nieokreślony tryb wywoływania funkcji. Nie należy używać tej wartości.
`AUTO`	Domyślne działanie modelu: model decyduje, czy przewidzieć wywołanie funkcji, czy odpowiedź w języku naturalnym.
`ANY`	Model jest ograniczony do przewidywania tylko wywołań funkcji. Jeśli ustawiono parametr „allowedFunctionNames”, przewidywane wywołanie funkcji będzie ograniczone do dowolnej z funkcji „allowedFunctionNames”. W przeciwnym razie przewidywane wywołanie funkcji będzie dowolną z funkcji „functionDeclarations”.
`NONE`	Model nie będzie prognozować żadnego wywołania funkcji. Działanie modelu jest takie samo jak w przypadku, gdy nie przekazujesz żadnych deklaracji funkcji.
`VALIDATED`	Model decyduje, czy przewidzieć wywołanie funkcji, czy odpowiedź w języku naturalnym, ale będzie weryfikować wywołania funkcji za pomocą dekodowania z ograniczeniami. Jeśli ustawiono parametr „allowedFunctionNames”, przewidywane wywołanie funkcji będzie ograniczone do dowolnej z funkcji „allowedFunctionNames”. W przeciwnym razie przewidywane wywołanie funkcji będzie dowolną z funkcji „functionDeclarations”.

RetrievalConfig

Konfiguracja pobierania.

Pola

latLng object (LatLng)

Opcjonalnie. Lokalizacja użytkownika.

languageCode string

Opcjonalnie. Kod języka użytkownika. Kod języka treści. Używaj tagów języka zdefiniowanych przez BCP47.

Zapis JSON
{ "latLng": { object (`LatLng`) }, "languageCode": string }

LatLng

Obiekt reprezentujący parę szerokości i długości geograficznej. Jest to para liczb zmiennoprzecinkowych podwójnej precyzji, które reprezentują stopnie szerokości i długości geograficznej. O ile nie określono inaczej, ten obiekt musi być zgodny ze standardem WGS84. Wartości muszą mieścić się w znormalizowanych zakresach.

Pola

latitude number

Szerokość geograficzna w stopniach. Musi mieścić się w zakresie od –90,0 do +90,0.

longitude number

Długość geograficzna w stopniach. Musi mieścić się w zakresie od –180,0 do +180,0.

Zapis JSON
{ "latitude": number, "longitude": number }

UsageMetadata

Metadane dotyczące korzystania z treści w pamięci podręcznej.

Pola

totalTokenCount integer

Łączna liczba tokenów, które zużywają treści w pamięci podręcznej.

Zapis JSON
{ "totalTokenCount": integer }