Buforowanie kontekstu

W typowym przepływie pracy związanym z AI można wielokrotnie przekazywać te same tokeny wejściowe do modelu. Korzystając z funkcji buforowania kontekstu w interfejsie Gemini API, możesz przekazać modelowi pewną treść, zapisać w pamięci podręcznej tokeny wejściowe, a następnie odwoływać się do tych tokenów w kolejnych żądaniach. Przy pewnych wolumenach korzystanie z tokenów w pamięci podręcznej jest tańsze niż wielokrotne przekazywanie tego samego zbioru tokenów.

Gdy przechowujesz w pamięci podręcznej zestaw tokenów, możesz określić, jak długo ma ona istnieć, zanim tokeny zostaną automatycznie usunięte. Czas buforowania jest nazywany czasem życia danych (TTL). Jeśli nie jest ustawiony, domyślny czas życia wynosi 1 godzinę. Koszt buforowania zależy od rozmiaru tokena wejściowego i tego, jak długo mają być przechowywane.

Buforowanie kontekstu obsługuje modele Gemini 1.5 Pro i Gemini 1.5 Flash.

Kiedy używać buforowania kontekstu

Kontekstowe buforowanie sprawdza się szczególnie w sytuacjach, w których znaczny kontekst początkowy jest wielokrotnie odwoływany do krótszych żądań. Zastanów się nad użyciem buforowania kontekstu w przypadku:

  • Czatboty z rozbudowanymi instrukcjami systemowymi
  • Wielokrotne analizowanie długich plików wideo
  • Cykliczne zapytania dotyczące dużych zbiorów dokumentów
  • częsta analiza repozytorium kodu lub poprawianie błędów;

Jak buforowanie zmniejsza koszty

Pamięć podręczna kontekstu to płatna funkcja, która ma na celu obniżenie ogólnych kosztów operacyjnych. Płatności są ustalane na podstawie następujących czynników:

  1. Cache token count (Liczba tokenów pamięci podręcznej): liczba tokenów wejściowych w pamięci podręcznej, które są rozliczane według niższej stawki, gdy są uwzględniane w kolejnych promptach.
  2. Czas przechowywania: czas przechowywania tokenów w pamięci podręcznej (TTL). Opłata jest obliczana na podstawie czasu TTL liczby tokenów w pamięci podręcznej. Nie ma minimalnej ani maksymalnej wartości TTL.
  3. Inne czynniki: obowiązują inne opłaty, np. za tokeny wejściowe i wyjściowe, które nie są przechowywane w pamięci podręcznej.

Aktualne informacje o cenach znajdziesz na tej stronie dotyczącej cen Gemini API. Więcej informacji o liczeniu tokenów znajdziesz w przewodniku po tokenach.

Jak korzystać z pamięci podręcznej kontekstu

W tej sekcji zakładamy, że masz zainstalowany pakiet SDK Gemini (lub masz zainstalowany curl) oraz skonfigurowany klucz interfejsu API zgodnie z instrukcjami w artykule Szybki start.

Generuj treści z wykorzystaniem pamięci podręcznej

Ten przykład pokazuje, jak generować treści za pomocą instrukcji systemu z poziomu pamięci podręcznej i pliku wideo.

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

Wyświetlanie pamięci podręcznej

Nie można pobrać ani wyświetlić treści z pamięci podręcznej, ale można pobrać metadane z pamięci podręcznej (name, model, displayName, usageMetadata, createTime, updateTime i expireTime).

Aby wyświetlić metadane wszystkich przesłanych pamięci podręcznych, użyj polecenia GoogleAICacheManager.list():

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

Aktualizowanie pamięci podręcznej

Możesz ustawić nową wartość ttl lub expireTime dla pamięci podręcznej. Zmiana innych ustawień pamięci podręcznej nie jest obsługiwana.

Ten przykład pokazuje, jak za pomocą funkcji GoogleAICacheManager.update() zaktualizować ttl pamięci podręcznej.

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

Usuwanie pamięci podręcznej

Usługa buforowania umożliwia ręczne usuwanie treści z pamięci podręcznej. Poniższy przykład pokazuje, jak usunąć pamięć podręczną za pomocą GoogleAICacheManager.delete().

await cacheManager.delete(cacheName);

Uwagi dodatkowe

Gdy korzystasz z pamięci podręcznej kontekstu, pamiętaj o tych kwestiach:

  • Minimalna liczba tokenów wejściowych do przechowywania w pamięci podręcznej w kontekście to 32 768, a maksymalna jest taka sama jak maksymalna liczba tokenów dla danego modelu. Więcej informacji o liczeniu tokenów znajdziesz w przewodniku po tokenach.
  • W modelu nie ma rozróżnienia między tokenami w pamięci podręcznej a zwykłymi tokenami wejściowymi. Treść w pamięci podręcznej jest po prostu prefiksem promptu.
  • Nie ma żadnych specjalnych limitów szybkości ani limitów użycia w przypadku buforowania kontekstu. Obowiązują standardowe limity szybkości dla GenerateContent, a limity tokenów obejmują tokeny buforowane.
  • Liczba tokenów zapisanych w pamięci podręcznej jest zwracana w funkcji usage_metadata podczas operacji tworzenia, pobierania i wyświetlania listy usług pamięci podręcznej, a także w GenerateContent, gdy używasz pamięci podręcznej.