Em um fluxo de trabalho de IA típico, é possível transmitir os mesmos tokens de entrada várias vezes para um modelo. Com o recurso de armazenamento em cache de contexto da API Gemini, é possível transmitir algum conteúdo para o modelo uma vez, armazenar os tokens de entrada em cache e consultá-los para as próximas solicitações. Em alguns volumes, o uso de tokens em cache tem um custo menor do que o envio repetido do mesmo corpus de tokens.
Ao armazenar em cache um conjunto de tokens, você pode escolher por quanto tempo o cache vai existir antes que os tokens sejam excluídos automaticamente. Essa duração de armazenamento em cache é chamada de time to live (TTL). Se ela não for definida, o padrão de TTL será uma hora. O custo de armazenamento em cache depende do tamanho do token de entrada e por quanto tempo você quer que os tokens permaneçam.
O armazenamento em cache de contexto tem suporte ao Gemini 1.5 Pro e ao Gemini 1.5 Flash.
Quando usar o armazenamento em cache de contexto
O armazenamento em cache de contexto é particularmente adequado para cenários em que um contexto inicial substancial é referenciado repetidamente por solicitações mais curtas. Use armazenamento em cache de contexto para casos de uso como estes:
- Chatbots com instruções detalhadas do sistema
- Análise repetitiva de arquivos de vídeo longos
- Consultas recorrentes em grandes conjuntos de documentos
- Análise frequente do repositório de código ou correção de bugs
Como o armazenamento em cache reduz os custos
O armazenamento em cache de contexto é um recurso pago projetado para reduzir os custos operacionais gerais. O faturamento é baseado nos seguintes fatores:
- Contagem de tokens de cache: o número de tokens de entrada armazenados em cache, faturados com uma taxa reduzida quando incluído nos comandos subsequentes.
- Duração do armazenamento: o tempo de armazenamento e cobrança dos tokens em cache (TTL), faturado com base na duração do TTL da contagem de tokens em cache. Não há limites mínimos ou máximos no TTL.
- Outros fatores: outras cobranças se aplicam, como tokens de entrada não armazenados em cache e tokens de saída.
Para detalhes atualizados sobre preços, consulte a página de preços da API Gemini. Para saber como contar tokens, consulte o guia de tokens.
Como usar o armazenamento em cache de contexto
Nesta seção, presumimos que você instalou um SDK do Gemini (ou o curl) e configurou uma chave de API, conforme mostrado no Guia de início rápido.
Gerar conteúdo usando um cache
O exemplo a seguir mostra como gerar conteúdo usando uma instrução do sistema em cache e um arquivo de vídeo.
import { GoogleGenerativeAI } from '@google/generative-ai';
import {
FileState,
GoogleAICacheManager,
GoogleAIFileManager,
} from '@google/generative-ai/server';
// A helper function that uploads the video to be cached.
async function uploadMp4Video(filePath, displayName) {
const fileManager = new GoogleAIFileManager(process.env.API_KEY);
const fileResult = await fileManager.uploadFile(filePath, {
displayName,
mimeType: 'video/mp4',
});
const { name, uri } = fileResult.file;
// Poll getFile() on a set interval (2 seconds here) to check file state.
let file = await fileManager.getFile(name);
while (file.state === FileState.PROCESSING) {
console.log('Waiting for video to be processed.');
// Sleep for 2 seconds
await new Promise((resolve) => setTimeout(resolve, 2_000));
file = await fileManager.getFile(name);
}
console.log(`Video processing complete: ${uri}`);
return fileResult;
}
// Download video file
// curl -O https://storage.googleapis.com/generativeai-downloads/data/Sherlock_Jr_FullMovie.mp4
const pathToVideoFile = 'Sherlock_Jr_FullMovie.mp4';
// Upload the video.
const fileResult = await uploadMp4Video(pathToVideoFile, 'Sherlock Jr. video');
// Construct a GoogleAICacheManager using your API key.
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
// Create a cache with a 5 minute TTL.
const displayName = 'sherlock jr movie';
const model = 'models/gemini-1.5-flash-001';
const systemInstruction =
'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.";
let ttlSeconds = 300;
const cache = await cacheManager.create({
model,
displayName,
systemInstruction,
contents: [
{
role: 'user',
parts: [
{
fileData: {
mimeType: fileResult.file.mimeType,
fileUri: fileResult.file.uri,
},
},
],
},
],
ttlSeconds,
});
// Get your API key from https://aistudio.google.com/app/apikey
// Access your API key as an environment variable.
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
// Construct a `GenerativeModel` which uses the cache object.
const genModel = genAI.getGenerativeModelFromCachedContent(cache);
// Query the model.
const result = await genModel.generateContent({
contents: [
{
role: 'user',
parts: [
{
text:
'Introduce different characters in the movie by describing ' +
'their personality, looks, and names. Also list the ' +
'timestamps they were introduced for the first time.',
},
],
},
],
});
console.log(result.response.usageMetadata);
// The output should look something like this:
//
// {
// promptTokenCount: 696220,
// candidatesTokenCount: 270,
// totalTokenCount: 696490,
// cachedContentTokenCount: 696191
// }
console.log(result.response.text());
Listar caches
Não é possível recuperar ou visualizar o conteúdo armazenado em cache, mas é possível recuperar
metadados de cache (name
, model
, displayName
, usageMetadata
,
createTime
, updateTime
e expireTime
).
Para listar os metadados de todos os caches enviados, use GoogleAICacheManager.list()
:
const listResult = await cacheManager.list();
listResult.cachedContents.forEach((cache) => {
console.log(cache);
});
Atualizar um cache
É possível definir um novo ttl
ou expireTime
para um cache. Não é possível mudar qualquer outra
coisa no cache.
O exemplo a seguir mostra como atualizar o ttl
de um cache usando
GoogleAICacheManager.update()
.
const ttlSeconds = 2 * 60 * 60;
const updateParams = { cachedContent: { ttlSeconds } };
const updatedCache = await cacheManager.update(cacheName, updateParams);
Excluir um cache
O serviço de armazenamento em cache fornece uma operação de exclusão para remover manualmente conteúdo do cache. O exemplo a seguir mostra como excluir um cache usando
GoogleAICacheManager.delete()
.
await cacheManager.delete(cacheName);
Outras considerações
Considere as seguintes considerações ao usar o armazenamento em cache de contexto:
- A contagem mínima de tokens de entrada para armazenamento em cache de contexto é 32.768, e a máxima é a mesma que a máxima para o modelo especificado. Para saber mais sobre a contagem de tokens, consulte o Guia de tokens.
- O modelo não faz distinção entre tokens em cache e tokens de entrada normais. O conteúdo armazenado em cache é simplesmente um prefixo para o comando.
- Não há limites especiais de taxa ou de uso no armazenamento em cache do contexto. Os limites
de taxa padrão para
GenerateContent
são aplicados e os limites de token incluem tokens em cache. - O número de tokens em cache é retornado no
usage_metadata
das operações de criação, acesso e listagem do serviço de cache e também emGenerateContent
ao usar o cache.