Wtyczka Google Generative AI

Wtyczka Google Generative AI udostępnia interfejsy modeli Gemini od Google za pomocą interfejsu Gemini API.

Instalacja

npm i --save @genkit-ai/googleai

Konfiguracja

Aby użyć tej wtyczki, określ ją podczas inicjowania Genkit:

import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
});

Aby korzystać z wtyczki, musisz mieć klucz API dla Gemini API, który możesz uzyskać w Google AI Studio.

Aby skonfigurować wtyczkę do używania klucza interfejsu API, wykonaj jedną z tych czynności:

  • Ustaw zmienną środowiskową GOOGLE_GENAI_API_KEY na swój klucz interfejsu API.

  • Podczas inicjowania wtyczki podaj klucz interfejsu API:

    googleAI({ apiKey: yourKey });

    Nie umieszczaj jednak klucza API bezpośrednio w kodzie. Używaj tej funkcji tylko w połączeniu z usługą, taką jak Cloud Secret Manager lub podobną.

Wykorzystanie

Ta wtyczka eksportuje statycznie odwołania do obsługiwanych modeli:

import {
  gemini15Flash,
  gemini15Pro,
  textEmbedding004,
} from '@genkit-ai/googleai';

Za pomocą tych odwołań możesz określić, którego modelu używa funkcja generate():

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

const llmResponse = await ai.generate('Tell me a joke.');

lub używać wtyczek (np. textEmbedding004) z embed lub z programem do pobierania:

const ai = genkit({
  plugins: [googleAI()],
});

const embedding = await ai.embed({
  embedder: textEmbedding004,
  content: input,
});

Gemini Files API

Pliki przesłane do interfejsu Gemini Files API możesz używać w Genkit:

import { GoogleAIFileManager } from '@google/generative-ai/server';
import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
});

const fileManager = new GoogleAIFileManager(process.env.GOOGLE_GENAI_API_KEY);
const uploadResult = await fileManager.uploadFile(
  'path/to/file.jpg',
  {
    mimeType: 'image/jpeg',
    displayName: 'Your Image',
  }
);

const response = await ai.generate({
  model: gemini15Flash,
  prompt: [
    {text: 'Describe this image:'},
    {media: {contentType: uploadResult.file.mimeType, url: uploadResult.file.uri}}
  ]
});

Modele dostrojone

Możesz używać modeli dostrojonych za pomocą interfejsu Gemini API od Google. Postępuj zgodnie z instrukcjami dotyczącymi Gemini API lub dostosuj model za pomocą AI Studio.

Proces strojenia wykorzystuje model podstawowy (np. Gemini 1.5 Flash) oraz przesłane przez Ciebie przykłady, aby utworzyć nowy dostrojony model. Zapamiętaj użyty model podstawowy i skopiuj identyfikator nowego modelu.

Podczas wywoływania dostosowanego modelu w Genkit użyj modelu podstawowego jako parametru model, a identyfikator dostosowanego modelu prześlij w ramach bloku config. Jeśli na przykład jako model podstawowy użyjesz modelu Gemini 1.5 Flash i uzyskasz identyfikator modelu tunedModels/my-example-model-apbm8oqbvuv2, możesz go wywołać za pomocą:

const ai = genkit({
  plugins: [googleAI()],
});

const llmResponse = await ai.generate({
  prompt: `Suggest an item for the menu of fish themed restruant`,
  model: gemini15Flash.withConfig({
    version: "tunedModels/my-example-model-apbm8oqbvuv2",
  }),
});

Buforowanie kontekstu

Wtyczka Google Generative AI obsługuje przechowywanie w pamięci podręcznej kontekstu, co pozwala modelom ponownie używać wcześniej zapisanych treści w pamięci podręcznej w celu optymalizacji wydajności i skracania czasu oczekiwania w przypadku powtarzających się zadań. Ta funkcja jest szczególnie przydatna w przypadku ścieżek konwersacyjnych lub scenariuszy, w których model konsekwentnie odwołuje się do dużego fragmentu tekstu w różnych żądaniach.

Jak korzystać z zapamiętywania kontekstu

Aby włączyć buforowanie kontekstu, upewnij się, że Twój model to obsługuje. Na przykład modele gemini15Flash i gemini15Pro obsługują buforowanie kontekstu.

Mechanizm buforowania możesz zdefiniować w aplikacji w ten sposób:

const ai = genkit({
  plugins: [googleAI()],
});

const llmResponse = await ai.generate({
  messages: [
    {
      role: 'user',
      content: [{ text: 'Here is the relevant text from War and Peace.' }],
    },
    {
      role: 'model',
      content: [
        {
          text: 'Based on War and Peace, here is some analysis of Pierre Bezukhov’s character.',
        },
      ],
      metadata: {
        cache: {
          ttlSeconds: 300, // Cache this message for 5 minutes
        },
      },
    },
  ],
  model: gemini15Flash,
  config: {
    version: 'gemini-1.5-flash-001', // Only 001 currently supports context caching
  },
  prompt: 'Describe Pierre’s transformation throughout the novel.',
});

W tej konfiguracji:messages: umożliwia przekazywanie historii rozmów. – metadata.cache.ttlSeconds: określa czas życia danych (TTL) dla pamięci podręcznej konkretnej odpowiedzi.

Przykład: wykorzystanie dużych tekstów z kontekstem

W przypadku aplikacji odwołujących się do długich dokumentów, takich jak Wojna i pokój czy Władca Pierścieni, możesz sformułować zapytania w taki sposób, aby ponownie używać kontekstów z pamięci podręcznej:

const fs = require('fs/promises');

const textContent = await fs.readFile('path/to/war_and_peace.txt', 'utf-8');

const llmResponse = await ai.generate({
  messages: [
    {
      role: 'user',
      content: [{ text: textContent }], // Include the large text as context
    },
    {
      role: 'model',
      content: [
        {
          text: 'This analysis is based on the provided text from War and Peace.',
        },
      ],
      metadata: {
        cache: {
          ttlSeconds: 300, // Cache the response to avoid reloading the full text
        },
      },
    },
  ],
  model: gemini15Flash,
  config: {
    version: 'gemini-1.5-flash-001', // Only 001 currently supports context caching
  },
  prompt: 'Analyze the relationship between Pierre and Natasha.',
});

Buforowanie innych trybów treści

Modele Gemini są multimodalne, a dozwolone jest również umieszczanie w pamięci podręcznej innych typów treści.

Aby na przykład zapisać w pamięci podręcznej długi fragment treści wideo, musisz najpierw przesłać go za pomocą menedżera plików z pakietu Google AI SDK:

import { GoogleAIFileManager } from '@google/generative-ai/server';


const fileManager = new GoogleAIFileManager(
  process.env.GOOGLE_GENAI_API_KEY
);

// Upload video to Google AI using the Gemini Files API
const uploadResult = await fileManager.uploadFile(videoFilePath, {
  mimeType: 'video/mp4', // Adjust according to the video format
  displayName: 'Uploaded Video for Analysis',
});

const fileUri = uploadResult.file.uri;

Teraz możesz skonfigurować pamięć podręczną w przypadku połączeń do ai.generate:

const analyzeVideoResponse = await ai.generate({
  messages: [
    {
      role: 'user',
      content: [
        {
          media: {
            url: fileUri, // Use the uploaded file URL
            contentType: 'video/mp4',
          },
        },
      ],
    },
    {
      role: 'model',
      content: [
        {
          text: 'This video seems to contain several key moments. I will analyze it now and prepare to answer your questions.',
        },
      ],
      // Everything up to (including) this message will be cached.
      metadata: {
        cache: true,
      },
    },
  ],
  config: {
    version: 'gemini-1.5-flash-001', // Only 001 versions support context caches
  },
  model: gemini15Flash,
  prompt: query,
});

Obsługiwane modele w przypadku buforowania kontekstu

Tylko niektóre modele, np. gemini15Flash i gemini15Pro, obsługują buforowanie kontekstu. Jeśli użyjesz nieobsługiwanego modelu, pojawi się błąd informujący, że nie można zastosować pamięci podręcznej.

Więcej informacji

Więcej informacji o zapamiętywaniu kontekstu w Google AI znajdziesz w dokumentacji.