Plug-in Google IA générative

Le plug-in Google Generative AI fournit des interfaces avec les modèles Gemini de Google via l'API Gemini.

Installation

npm i --save @genkit-ai/googleai

Configuration

Pour utiliser ce plug-in, spécifiez-le lorsque vous initialisez Genkit:

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

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

Le plug-in nécessite une clé API pour l'API Gemini, que vous pouvez obtenir dans Google AI Studio.

Configurez le plug-in pour qu'il utilise votre clé API en procédant comme suit:

  • Définissez la variable d'environnement GOOGLE_GENAI_API_KEY sur votre clé API.

  • Spécifiez la clé API lorsque vous initialisez le plug-in:

    googleAI({ apiKey: yourKey });

    Toutefois, n'intégrez pas votre clé API directement dans le code. N'utilisez cette fonctionnalité qu'en conjonction avec un service tel que Cloud Secret Manager ou un service similaire.

Utilisation

Ce plug-in exporte de manière statique les références à ses modèles compatibles:

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

Vous pouvez utiliser ces références pour spécifier le modèle utilisé par generate():

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

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

ou utiliser des outils d'intégration (par exemple, textEmbedding004) avec embed ou des récupérateurs:

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

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

API Gemini Files

Vous pouvez utiliser les fichiers importés dans l'API Gemini Files avec 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}}
  ]
});

Modèles affinés

Vous pouvez utiliser des modèles affinés avec l'API Google Gemini. Suivez les instructions de l'API Gemini ou affinez un modèle à l'aide de AI Studio.

Le processus de réglage utilise un modèle de base (par exemple, Gemini 1.5 Flash) et les exemples que vous avez fournis pour créer un modèle réglé. N'oubliez pas le modèle de base que vous avez utilisé et copiez l'ID du nouveau modèle.

Lorsque vous appelez le modèle affiné dans Genkit, utilisez le modèle de base comme paramètre model et transmettez l'ID du modèle affiné dans le bloc config. Par exemple, si vous avez utilisé Gemini 1.5 Flash comme modèle de base et que vous avez obtenu l'ID de modèle tunedModels/my-example-model-apbm8oqbvuv2, vous pouvez l'appeler avec:

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

Mise en cache du contexte

Le plug-in Google IA générative est compatible avec la mise en cache de contexte, qui permet aux modèles de réutiliser du contenu précédemment mis en cache pour optimiser les performances et réduire la latence des tâches répétitives. Cette fonctionnalité est particulièrement utile pour les flux de conversation ou les scénarios où le modèle fait référence à un grand volume de texte de manière cohérente sur plusieurs requêtes.

Utiliser la mise en cache de contexte

Pour activer la mise en cache de contexte, assurez-vous que votre modèle est compatible avec cette fonctionnalité. Par exemple, gemini15Flash et gemini15Pro sont des modèles compatibles avec la mise en cache de contexte.

Vous pouvez définir un mécanisme de mise en cache dans votre application comme suit:

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

Dans cette configuration : - messages: vous permet de transmettre l'historique des conversations. - metadata.cache.ttlSeconds: spécifie la valeur TTL (Time To Live) pour la mise en cache d'une réponse spécifique.

Exemple: Exploiter de longs textes avec le contexte

Pour les applications qui font référence à des documents longs, tels que Guerre et Paix ou Le Seigneur des anneaux, vous pouvez structurer vos requêtes pour réutiliser les contextes mis en cache:

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

Mettre en cache d'autres modes de contenu

Les modèles Gemini sont multimodaux, et d'autres modes de contenu peuvent également être mis en cache.

Par exemple, pour mettre en cache un long contenu vidéo, vous devez d'abord l'importer à l'aide du gestionnaire de fichiers du SDK Google AI:

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;

Vous pouvez maintenant configurer le cache dans vos appels à 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,
});

Modèles compatibles avec la mise en cache de contexte

Seuls certains modèles, tels que gemini15Flash et gemini15Pro, sont compatibles avec la mise en cache de contexte. Si un modèle non compatible est utilisé, une erreur s'affiche, indiquant que le cache ne peut pas être appliqué.

Documentation complémentaire

Pour en savoir plus sur la mise en cache de contexte dans Google AI, consultez la documentation.