Veo 3.1 już jest! Więcej informacji o nowym modelu i jego funkcjach znajdziesz w poście na blogu i w dokumentacji.

Ta strona została przetłumaczona przez Cloud Translation API.

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, np. gdy zadajesz różne pytania dotyczące 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. Niezmienne. Treść do umieszczenia w pamięci podręcznej.

tools[] object (Tool)

Opcjonalnie: Tylko dane wejściowe. Niezmienne. 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: Niezmienne. Wygenerowana przez użytkownika znacząca nazwa wyświetlana treści w pamięci podręcznej. Maksymalnie 128 znaków Unicode.

model string

Wymagane. Niezmienne. 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. Niezmienne. Instrukcja systemowa ustawiona przez dewelopera. Obecnie tylko tekst.

toolConfig object (ToolConfig)

Opcjonalnie: Tylko dane wejściowe. Niezmienne. 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

Przeczytaj

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

Przeczytaj

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

Przeczytaj

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 zwracanych treści z pamięci podręcznej. 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}. Przyjmuje 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

Przeczytaj

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 aktualizować tylko datę ważności).

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}. Przyjmuje postać cachedContents/{cachedcontent}.

Parametry zapytania

updateMask string (FieldMask format)

Lista pól do zaktualizowania.

Jest to lista w pełni kwalifikowanych nazw pól rozdzielonych 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

Przeczytaj

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}. Przyjmuje 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

Przeczytaj

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

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. Niezmienne. Treść do umieszczenia w pamięci podręcznej.

tools[] object (Tool)

Opcjonalnie: Tylko dane wejściowe. Niezmienne. 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: Niezmienne. Wygenerowana przez użytkownika znacząca nazwa wyświetlana treści w pamięci podręcznej. Maksymalnie 128 znaków Unicode.

model string

Wymagane. Niezmienne. 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. Niezmienne. Instrukcja systemowa ustawiona przez dewelopera. Obecnie tylko tekst.

toolConfig object (ToolConfig)

Opcjonalnie: Tylko dane wejściowe. Niezmienne. 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”.

Przydatne w przypadku rozmów wieloetapowych. W innych przypadkach można pozostawić to pole puste lub nie ustawiać go.

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

Część

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

Part składa się z danych, z którymi powiązany jest typ 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, dzięki czemu można go używać w kolejnych żądaniach.

Ciąg znaków 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.

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.

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 }, // data "text": string, "inlineData": { object (`Blob`) }, "functionCall": { object (`FunctionCall`) }, "functionResponse": { object (`FunctionResponse`) }, "fileData": { object (`FileData`) }, "executableCode": { object (`ExecutableCode`) }, "codeExecutionResult": { object (`CodeExecutionResult`) } // Union type // metadata "videoMetadata": { object (`VideoMetadata`) } // Union type }

{
  "thought": boolean,
  "thoughtSignature": string,
  "partMetadata": {
    object
  },

  // data
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  }
  // 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 podasz nieobsługiwany typ MIME, zwrócimy błąd. Pełną listę obsługiwanych typów znajdziesz w artykule Obsługiwane formaty plików.

data string (bytes format)

Nieprzetworzone bajty w przypadku formatów multimedialnych.

Ciąg znaków 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 64 znaki.

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 64 znaki.

response object (Struct format)

Wymagane. Odpowiedź funkcji w formacie obiektu JSON. Wywołujący mogą używać dowolnych kluczy pasujących 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ć szczegóły błędu do modelu.

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ąć wygenerowania i zakończenia wywołania 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, z którymi powiązany jest typ 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 znaków 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 IANA danych źródłowych.

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

language enum (Language)

Wymagane. Język programowania code.

code string

Wymagane. Kod do wykonania.

Zapis JSON
{ "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.

CodeExecutionResult

Wynik wykonania funkcji ExecutableCode.

Generowany tylko wtedy, gdy używasz CodeExecution, i zawsze występuje po part zawierającym ExecutableCode.

Pola

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
{ "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.
`OUTCOME_FAILED`	Wykonanie kodu zostało zakończone, ale z błędem. `stderr` powinien zawierać powód.
`OUTCOME_DEADLINE_EXCEEDED`	Wykonanie kodu trwało zbyt długo i zostało anulowane. Może być dostępny częściowy wynik.

VideoMetadata

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 }

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: 12

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 FunctionCall w odpowiedzi. 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.

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`) } }

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

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 64 znaki.

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ę wzajemnie z polem parameters.

response object (Schema)

Opcjonalnie: Opisuje dane wyjściowe tej funkcji w formacie JSON Schema. 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 JSON Schema. Wartość określona przez schemat jest wartością odpowiedzi funkcji.

To pole wyklucza się wzajemnie 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 w przypadku 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 Type.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ść Type.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 on uwzględniany i ignorowany, 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 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ść 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 zdefiniowanych 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 włączona, 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 utrzymaniu 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).

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

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 }

ComputerUse

Typ narzędzia Computer Use.

Pola

environment enum (Environment)

Wymagane. środowisko, w którym działa usługa;

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

retrievalResources[] object (RetrievalResource)

Wymagane. Zasoby pobierania semantycznego, z których chcesz pobrać dane. Obecnie obsługuje tylko 1 korpus. W przyszłości możemy udostępnić obsługę wielu korpusów.

retrievalConfig object (RetrievalConfig)

Opcjonalnie: Konfiguracja pobierania.

Zapis JSON
{ "retrievalResources": [ { object (`RetrievalResource`) } ], "retrievalConfig": { object (`RetrievalConfig`) } }

RetrievalResource

Zasób pobierania semantycznego, z którego chcesz pobrać dane.

Pola

ragStoreName string

Wymagane. Nazwa zasobu wyszukiwania semantycznego, z którego chcesz pobrać dane. Przykład: ragStores/my-rag-store-123

Zapis JSON
{ "ragStoreName": string }

RetrievalConfig

Konfiguracja wyszukiwania semantycznego.

Pola

metadataFilter string

Opcjonalnie: Filtr metadanych, który ma być stosowany do dokumentów i fragmentów pobranych za pomocą wyszukiwania semantycznego.

topK integer

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

Zapis JSON
{ "metadataFilter": string, "topK": integer }

ToolConfig

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

Pola

functionCallingConfig object (FunctionCallingConfig)

Opcjonalnie: Konfiguracja wywoływania funkcji.

Zapis JSON
{ "functionCallingConfig": { object (`FunctionCallingConfig`) } }

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

To ustawienie powinno być stosowane tylko wtedy, gdy tryb ma wartość 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”.

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 }