上下文缓存
在典型的 AI 工作流程中,您可能会将相同的输入 token 一遍又一遍地传递给模型。 Gemini API 提供两种不同的缓存机制:
- 隐式缓存(在 Gemini 2.5 及更新型号上自动启用,无成本节省保证)
- 显式缓存(可在Gemini 3和2.5型号上手动启用,节省成本保证;Gemini 4型号不支持)
当您想要保证节省成本但需要增加一些开发人员工作时,显式缓存非常有用。
隐式缓存 #
默认情况下,所有 Gemini、2.5 及更新型号均启用隐式缓存。如果您的请求命中缓存,我们会自动节省成本。您无需配置任何内容即可将其打开。下表列出了每个型号的最小输入 token 数量:
| 模型 | 最小 token 限制 |
|---|---|
| Gemini 4 Carbon | 4,096 |
| Gemini 4 Argon | 4,096 |
| Gemini 4 Hydrogen | 4,096 |
| Gemini 3.8 Flash | 4,096 |
| Gemini 3.6 Flash | 4,096 |
| Gemini 3.1 Pro Preview | 4,096 |
| Gemini 2.5 Flash | 2,048 |
| Gemini 2.5 Pro | 2,048 |
要增加隐式缓存命中的机会:
- 尝试将大而常见的内容放在提示的开头
- 尝试在短时间内发送具有相似前缀的请求
您可以在响应对象的缓存命中中看到 token 的数量 usage_metadata 场。
显式缓存 #
使用Gemini API显式缓存功能,您可以将一些内容传递给模型一次,缓存输入token,然后在后续请求时引用缓存的token。在某些数量上,使用缓存的 token 比重复传递 token 的同一语料库的成本更低。
当您缓存一组 token 时,您可以选择在 token 被自动删除之前希望缓存存在多长时间。该缓存持续时间称为 生存时间 (TTL)。如果未设置,TTL 默认为 1 小时。缓存的成本取决于输入 token 的大小以及您希望 token 保留的时间。
本节假设您已经安装了 Gemini SDK(或安装了curl)并且您已经配置了 API 密钥,如 入门指南.
使用缓存生成内容 #
以下示例演示如何使用缓存的系统指令和视频文件生成内容。
import os
import pathlib
import requests
import time
from google import genai
from google.genai import types
client = genai.Client(http_options={"api_version": "v1beta"})
# Download a test video file and save it locally
url = 'https://storage.googleapis.com/generativeai-downloads/data/SherlockJr._10min.mp4'
path_to_video_file = pathlib.Path('SherlockJr._10min.mp4')
if not path_to_video_file.exists():
path_to_video_file.write_bytes(requests.get(url).content)
# Upload the video using the Files API
video_file = client.files.upload(file=path_to_video_file)
# Wait for the file to finish processing
while video_file.state.name == 'PROCESSING':
time.sleep(2.5)
video_file = client.files.get(name=video_file.name)
print(f'Video processing complete: {video_file.uri}')
model='models/gemini-3.8-flash'
# Create a cache with a 5 minute TTL (300 seconds)
cache = client.caches.create(
model=model,
config=types.CreateCachedContentConfig(
display_name='sherlock jr movie', # used to identify the cache
system_instruction=(
'You are an expert video analyzer, and your job is to answer '
'the user\'s query based on the video file you have access to.'
),
contents=[video_file],
ttl="300s",
)
)
response = client.models.generate_content(
model = model,
contents= (
'Introduce different characters in the movie by describing '
'their personality, looks, and names. Also list the timestamps '
'they were introduced for the first time.'),
config=types.GenerateContentConfig(cached_content=cache.name)
)
print(response.usage_metadata)
print(response.text)
from google import genai
from google.genai import types
import io
import httpx
client = genai.Client(http_options={"api_version": "v1beta"})
long_context_pdf_path = "https://sma.nasa.gov/SignificantIncidents/assets/a11_missionreport.pdf"
# Retrieve and upload the PDF using the File API
doc_io = io.BytesIO(httpx.get(long_context_pdf_path).content)
document = client.files.upload(
file=doc_io,
config=dict(mime_type='application/pdf')
)
model_name = "gemini-3.8-flash"
system_instruction = "You are an expert analyzing transcripts."
# Create a cached content object
cache = client.caches.create(
model=model_name,
config=types.CreateCachedContentConfig(
system_instruction=system_instruction,
contents=[document],
)
)
print(f'{cache=}')
response = client.models.generate_content(
model=model_name,
contents="Please summarize this transcript",
config=types.GenerateContentConfig(
cached_content=cache.name
))
print(f'{response.usage_metadata=}')
print('\n\n', response.text)
以下示例演示如何使用缓存的系统指令和文本文件生成内容。
import {
GoogleGenAI,
createUserContent,
createPartFromUri,
} from "@google/genai";
const ai = new GoogleGenAI({ apiKey: "GEMINI_API_KEY", httpOptions: { apiVersion: "v1beta" } });
async function main() {
const doc = await ai.files.upload({
file: "path/to/file.txt",
config: { mimeType: "text/plain" },
});
console.log("Uploaded file name:", doc.name);
const modelName = "gemini-3.8-flash";
const cache = await ai.caches.create({
model: modelName,
config: {
contents: createUserContent(createPartFromUri(doc.uri, doc.mimeType)),
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);
}
await main();
以下示例演示如何使用缓存生成内容。
package main
import (
"context"
"fmt"
"log"
"google.golang.org/genai"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
HTTPOptions: genai.HTTPOptions{APIVersion: "v1beta"},
APIKey: "GOOGLE_API_KEY",
Backend: genai.BackendGeminiAPI,
})
if err != nil {
log.Fatal(err)
}
modelName := "gemini-3.8-flash"
document, err := client.Files.UploadFromPath(
ctx,
"media/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) // helper for printing response parts
}
以下示例演示如何创建缓存,然后使用它来生成内容。
wget https://storage.googleapis.com/generativeai-downloads/data/a11.txt
echo '{
"model": "models/gemini-3.8-flash",
"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-3.8-flash:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
"contents": [
{
"parts":[{
"text": "Please summarize this transcript"
}],
"role": "user"
},
],
"cachedContent": "'"$CACHE_NAME"'"
}'
DOC_URL="https://sma.nasa.gov/SignificantIncidents/assets/a11_missionreport.pdf"
DISPLAY_NAME="A11_Mission_Report"
SYSTEM_INSTRUCTION="You are an expert at analyzing transcripts."
PROMPT="Please summarize this transcript"
MODEL="models/gemini-3.8-flash"
TTL="300s"
# Download the PDF
wget -O "${DISPLAY_NAME}.pdf" "${DOC_URL}"
MIME_TYPE=$(file -b --mime-type "${DISPLAY_NAME}.pdf")
NUM_BYTES=$(wc -c < "${DISPLAY_NAME}.pdf")
echo "MIME_TYPE: ${MIME_TYPE}"
echo "NUM_BYTES: ${NUM_BYTES}"
tmp_header_file=upload-header.tmp
# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
-D upload-header.tmp \
-H "X-Goog-Upload-Protocol: resumable" \
-H "X-Goog-Upload-Command: start" \
-H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
-H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
-H "Content-Type: application/json" \
-d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null
upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"
# Upload the actual bytes.
curl "${upload_url}" \
-H "Content-Length: ${NUM_BYTES}" \
-H "X-Goog-Upload-Offset: 0" \
-H "X-Goog-Upload-Command: upload, finalize" \
--data-binary "@${DISPLAY_NAME}.pdf" 2> /dev/null > file_info.json
file_uri=$(jq ".file.uri" file_info.json)
echo "file_uri: ${file_uri}"
# Clean up the downloaded PDF
rm "${DISPLAY_NAME}.pdf"
# Create the cached content request
echo '{
"model": "'"$MODEL"'",
"contents":[
{
"parts":[
{"file_data": {"mime_type": "'"$MIME_TYPE"'", "file_uri": '"$file_uri"'}}
],
"role": "user"
}
],
"system_instruction": {
"parts": [
{
"text": "'"$SYSTEM_INSTRUCTION"'"
}
],
"role": "system"
},
"ttl": "'"$TTL"'"
}' > request.json
# Send the cached content request
curl -X POST "${BASE_URL}/v1beta/cachedContents?key=$GOOGLE_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)
echo "CACHE_NAME: ${CACHE_NAME}"
# Send the generateContent request using the cached content
curl -X POST "${BASE_URL}/${MODEL}:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
"contents": [
{
"parts":[{
"text": "'"$PROMPT"'"
}],
"role": "user"
}
],
"cachedContent": "'"$CACHE_NAME"'"
}' > response.json
cat response.json
echo jq ".candidates[].content.parts[].text" response.json
列出缓存 #
无法检索或查看缓存内容,但您可以检索缓存元数据 (name, model, display_name, usage_metadata, create_time, update_time, 和 expire_time).
要列出所有上传缓存的元数据,请使用 CachedContent.list():
for cache in client.caches.list():
print(cache)
要获取一个缓存对象的元数据,如果您知道其名称,请使用 get:
client.caches.get(name=name)
要列出所有上传缓存的元数据,请使用 GoogleGenAI.caches.list():
console.log("My caches:");
const pager = await ai.caches.list({ config: { pageSize: 10 } });
let page = pager.page;
while (true) {
for (const c of page) {
console.log(" ", c.name);
}
if (!pager.hasNextPage()) break;
page = await pager.nextPage();
}
以下示例列出了所有缓存。
caches, err := client.Caches.All(ctx)
if err != nil {
log.Fatal(err)
}
fmt.Println("Listing all caches:")
for _, item := range caches {
fmt.Println(" ", item.Name)
}
以下示例列出了使用页面大小 2. 的缓存
page, err := client.Caches.List(ctx, &genai.ListCachedContentsConfig{PageSize: 2})
if err != nil {
log.Fatal(err)
}
pageIndex := 1
for {
fmt.Printf("Listing caches (page %d):\n", pageIndex)
for _, item := range page.Items {
fmt.Println(" ", item.Name)
}
if page.NextPageToken == "" {
break
}
page, err = page.Next(ctx)
if err == genai.ErrPageDone {
break
} else if err != nil {
return err
}
pageIndex++
}
curl "https://generativelanguage.googleapis.com/v1beta/cachedContents?key=$GEMINI_API_KEY"
更新缓存 #
您可以设置一个新的 ttl 或 expire_time 用于缓存。不支持更改有关缓存的任何其他内容。
以下示例展示了如何更新 ttl 缓存使用 client.caches.update().
from google import genai
from google.genai import types
client.caches.update(
name = cache.name,
config = types.UpdateCachedContentConfig(
ttl='300s'
)
)
要设置到期时间,它将接受 datetime 对象或 ISO 格式的日期时间字符串 (dt.isoformat(),像 2025-01-27T16:02:36.473528+00:00)。您的时间必须包含时区(datetime.utcnow() 不附加时区, datetime.now(datetime.timezone.utc) 确实附加了时区)。
from google import genai
from google.genai import types
import datetime
# You must use a time zone-aware time.
in10min = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=10)
client.caches.update(
name = cache.name,
config = types.UpdateCachedContentConfig(
expire_time=in10min
)
)
以下示例展示了如何更新 ttl 缓存使用 GoogleGenAI.caches.update().
const ttl = `${2 * 3600}s`; // 2 hours in seconds
const updatedCache = await ai.caches.update({
name: cache.name,
config: { ttl },
});
console.log("After update (TTL):", updatedCache);
以下示例展示了如何更新 TTL 缓存的。
// Update the TTL (2 hours).
cache, err = client.Caches.Update(ctx, cache.Name, &genai.UpdateCachedContentConfig{
TTL: 7200 * time.Second,
})
if err != nil {
log.Fatal(err)
}
fmt.Println("After update:")
fmt.Println(cache)
以下示例展示了如何更新 ttl 缓存的。
curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"ttl": "600s"}'
删除缓存 #
缓存服务提供删除操作,用于手动从缓存中删除内容。以下示例展示了如何删除缓存:
client.caches.delete(cache.name)
await ai.caches.delete({ name: cache.name });
_, err = client.Caches.Delete(ctx, cache.Name, &genai.DeleteCachedContentConfig{})
if err != nil {
log.Fatal(err)
}
fmt.Println("Cache deleted:", cache.Name)
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"
使用 OpenAI 库的显式缓存 #
如果您使用的是 OpenAI 库,您可以使用以下命令启用显式缓存 cached_content 属性于 extra_body.
何时使用显式缓存 #
上下文缓存特别适合较短的请求重复引用大量初始上下文的场景。考虑将上下文缓存用于以下用例:
- 具有广泛功能的聊天机器人 系统指令
- 冗长视频文件的重复分析
- 针对大型文档集的重复查询
- 频繁的代码存储库分析或错误修复
显式缓存如何降低成本 #
上下文缓存是一项付费功能,旨在降低成本。计费基于以下因素:
缓存 token 计数: 缓存的输入 token 数量,包含在后续提示中时按降低的费率计费。
储存期限: 缓存 token 的存储时间量 (TTL),根据缓存 token 计数的 TTL 持续时间计费。 TTL 没有最小或最大界限。
其他因素: 其他费用适用,例如非缓存输入 token 和输出 token。
有关最新定价详细信息,请参阅 Gemini API 定价页面。要了解如何计算 token,请参阅 代币指南.
其他注意事项 #
使用上下文缓存时请记住以下注意事项:
该 最小值 上下文缓存的输入 token 计数因型号而异。的 最大 与给定模型的最大值相同。 (有关计算 token 的更多信息,请参阅 代币指南).
该模型不会对缓存的 token 和常规输入 token 进行任何区分。缓存内容是提示的前缀。
上下文缓存没有特殊的费率或使用限制;标准速率限制
GenerateContent应用,并且 token 限制包括缓存的 token。返回缓存的token的数量
usage_metadata来自缓存服务的创建、获取和列表操作,以及GenerateContent使用缓存时。当请求使用显式缓存时,隐式缓存不适用。与显式缓存一起发送的任何附加输入 token 均按标准输入费率计费。