El almacenamiento de contexto en caché

En un flujo de trabajo de IA típico, puedes pasar los mismos tokens de entrada una y otra vez a un modelo. Con la función de almacenamiento en caché de contexto de la API de Gemini, puedes pasar parte del contenido al modelo una vez, almacenar en caché los tokens de entrada y, luego, consultar los tokens almacenados en caché para solicitudes posteriores. En ciertos volúmenes, usar tokens almacenados en caché tiene un costo más bajo que pasar el mismo corpus de tokens de forma reiterada.

Cuando almacenas en caché un conjunto de tokens, puedes elegir cuánto tiempo quieres que exista la caché antes de que los tokens se borren automáticamente. Esta duración del almacenamiento en caché se denomina el tiempo de actividad (TTL). Si no se establece, el TTL se establece de forma predeterminada en 1 hora. El costo de la caché depende del tamaño del token de entrada y de cuánto tiempo deseas que persistan los tokens.

El almacenamiento en caché de contexto admite Gemini 1.5 Pro y Gemini 1.5 Flash.

Cuándo usar el almacenamiento en caché de contexto

El almacenamiento en caché de contexto es particularmente adecuado para situaciones en las que las solicitudes más cortas hacen referencia repetidamente a un contexto inicial sustancial. Considera usar el almacenamiento en caché de contexto para casos de uso como los siguientes:

  • Chatbots con instrucciones del sistema detalladas
  • Análisis repetitivo de archivos de video largos
  • Consultas recurrentes en conjuntos de documentos grandes
  • Análisis frecuente del repositorio de código o corrección de errores

Cómo la caché reduce los costos

La caché de contexto es una función pagada diseñada para reducir los costos operativos generales. La facturación se basa en los siguientes factores:

  1. Recuento de tokens de caché: Es la cantidad de tokens de entrada almacenados en caché que se facturan a una tarifa reducida cuando se incluyen en mensajes posteriores.
  2. Duración del almacenamiento: La cantidad de tiempo que se almacenan los tokens almacenados en caché (TTL), que se factura según la duración de TTL del recuento de tokens almacenados en caché. No hay límites mínimos ni máximos en el TTL.
  3. Otros factores: Se aplican otros cargos, como por los tokens de entrada y los tokens de salida que no están almacenados en caché.

Para obtener información actualizada sobre los precios, consulta la página de precios de la API de Gemini. Si deseas obtener información para contar tokens, consulta la guía de tokens.

Cómo usar el almacenamiento en caché de contexto

En esta sección, se da por sentado que instalaste un SDK de Gemini (o tienes instalado curl) y que configuraste una clave de API, como se muestra en la guía de inicio rápido.

Genera contenido con una caché

En el siguiente ejemplo, se muestra cómo generar contenido con una instrucción del sistema y un archivo de video almacenados en caché.

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

Enumera las cachés

No es posible recuperar ni ver el contenido almacenado en caché, pero sí los metadatos de la caché (name, model, displayName, usageMetadata, createTime, updateTime y expireTime).

Para enumerar los metadatos de todas las cachés subidas, usa GoogleAICacheManager.list():

const listResult = await cacheManager.list();
listResult.cachedContents.forEach((cache) => {
  console.log(cache);
});

Actualizar una caché

Puedes establecer un ttl o un expireTime nuevo para una caché. No se admite cambiar ningún otro elemento de la caché.

En el siguiente ejemplo, se muestra cómo actualizar el ttl de una caché con GoogleAICacheManager.update().

const ttlSeconds = 2 * 60 * 60;
const updateParams = { cachedContent: { ttlSeconds } };
const updatedCache = await cacheManager.update(cacheName, updateParams);

Borra una memoria caché

El servicio de almacenamiento en caché proporciona una operación de eliminación para quitar contenido de la caché de forma manual. En el siguiente ejemplo, se muestra cómo borrar una caché con GoogleAICacheManager.delete().

await cacheManager.delete(cacheName);

Consideraciones adicionales

Ten en cuenta las siguientes consideraciones cuando uses la caché de contexto:

  • El recuento mínimo de tokens de entrada para el almacenamiento en caché de contexto es 32,768 y el máximo es el mismo que el máximo para el modelo determinado. (Para obtener más información sobre el recuento de tokens, consulta la Guía de tokens).
  • El modelo no hace ninguna distinción entre los tokens almacenados en caché y los tokens de entrada regulares. El contenido almacenado en caché es simplemente un prefijo de la instrucción.
  • No hay límites de frecuencia ni de uso especiales en la caché de contexto. Se aplican los límites de frecuencia estándar para GenerateContent, y los límites de tokens incluyen los tokens almacenados en caché.
  • La cantidad de tokens almacenados en caché se muestra en usage_metadata desde las operaciones de creación, obtención y lista del servicio de caché, y también en GenerateContent cuando se usa la caché.