Google-Plug-in für generative KI

Das Google Generative AI-Plug-in bietet über die Gemini API Schnittstellen zu den Gemini-Modellen von Google.

Installation

npm i --save @genkit-ai/googleai

Konfiguration

Wenn Sie dieses Plug-in verwenden möchten, geben Sie es an, wenn Sie Genkit initialisieren:

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

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

Für das Plug-in ist ein API-Schlüssel für die Gemini API erforderlich, den Sie in Google AI Studio abrufen können.

Konfigurieren Sie das Plug-in so, dass es Ihren API-Schlüssel verwendet. Gehen Sie dazu so vor:

• Legen Sie die Umgebungsvariable GOOGLE_GENAI_API_KEY auf Ihren API-Schlüssel fest.

• Geben Sie den API-Schlüssel an, wenn Sie das Plug-in initialisieren:

  googleAI({ apiKey: yourKey });
  

  Betten Sie Ihren API-Schlüssel jedoch nicht direkt in den Code ein. Verwenden Sie diese Funktion nur in Verbindung mit einem Dienst wie Cloud Secret Manager oder einem ähnlichen Dienst.

Nutzung

Dieses Plug-in exportiert statisch Verweise auf die unterstützten Modelle:

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

Mit diesen Referenzen können Sie angeben, welches Modell für generate() verwendet wird:

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

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

oder Einbettungstools (z. B. textEmbedding004) mit embed oder Abrufen:

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

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

Gemini Files API

Sie können Dateien, die mit Genkit in die Gemini Files API hochgeladen wurden, so verwenden:

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}}
  ]
});

Optimierte Modelle

Sie können Modelle verwenden, die mit der Google Gemini API optimiert wurden. Folgen Sie der Anleitung in der Gemini API oder optimieren Sie ein Modell mit AI Studio.

Bei der Tuning-Aufgabe wird ein Basismodell (z. B. Gemini 1.5 Flash) und Ihre bereitgestellten Beispiele verwendet, um ein neues abgestimmtes Modell zu erstellen. Notieren Sie sich das verwendete Basismodell und kopieren Sie die ID des neuen Modells.

Verwenden Sie beim Aufrufen des optimierten Modells in Genkit das Basismodell als model-Parameter und geben Sie die ID des optimierten Modells als Teil des config-Blocks an. Wenn Sie beispielsweise Gemini 1.5 Flash als Basismodell verwendet und die Modell-ID tunedModels/my-example-model-apbm8oqbvuv2 erhalten haben, können Sie es so aufrufen:

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",
  }),
});

Kontext-Caching

Das Google-Plug-in für generative KI unterstützt das Kontext-Caching, mit dem Modelle zuvor im Cache gespeicherte Inhalte wiederverwenden können, um die Leistung zu optimieren und die Latenz bei sich wiederholenden Aufgaben zu reduzieren. Diese Funktion ist besonders nützlich für Konversationsabläufe oder Szenarien, in denen das Modell in mehreren Anfragen konsistent auf einen großen Textbestand verweist.

Kontext-Caching verwenden

Damit das Kontext-Caching aktiviert werden kann, muss Ihr Modell diese Funktion unterstützen. gemini15Flash und gemini15Pro sind beispielsweise Modelle, die das Kontext-Caching unterstützen.

So können Sie einen Caching-Mechanismus in Ihrer Anwendung definieren:

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.',
});

Bei dieser Konfiguration: – messages: Sie können den Unterhaltungsverlauf übergeben. – metadata.cache.ttlSeconds: Gibt die Gültigkeitsdauer (TTL) für das Caching einer bestimmten Antwort an.

Beispiel: Lange Texte mit Kontext nutzen

Bei Anwendungen, die auf lange Dokumente verweisen, z. B. Krieg und Frieden oder Der Herr der Ringe, können Sie Ihre Abfragen so strukturieren, dass zwischengespeicherte Kontexte wiederverwendet werden:

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.',
});

Andere Inhaltsmodi im Cache speichern

Die Gemini-Modelle sind multimodal und auch andere Inhaltsmodi dürfen im Cache gespeichert werden.

Wenn Sie beispielsweise einen langen Videoinhalt im Cache speichern möchten, müssen Sie ihn zuerst über den Dateimanager des Google AI SDK hochladen:

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;

Sie können den Cache jetzt in Ihren Aufrufen von ai.generate konfigurieren:

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,
});

Unterstützte Modelle für das Kontext-Caching

Nur bestimmte Modelle wie gemini15Flash und gemini15Pro unterstützen das Kontext-Caching. Wenn ein nicht unterstütztes Modell verwendet wird, wird ein Fehler ausgegeben, der darauf hinweist, dass das Caching nicht angewendet werden kann.

Weiterführende Literatur

Weitere Informationen zum Kontext-Caching bei Google AI finden Sie in der Dokumentation.