Plug-in di IA generativa di Google

Il plug-in di IA generativa di Google fornisce interfacce per i modelli Gemini di Google tramite l'API Gemini.

Installazione

npm i --save @genkit-ai/googleai

Configurazione

Per utilizzare questo plug-in, specificalo quando inizili Genkit:

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

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

Il plug-in richiede una chiave API per l'API Gemini, che puoi ottenere da Google AI Studio.

Configura il plug-in in modo che utilizzi la tua chiave API effettuando una delle seguenti operazioni:

  • Imposta la variabile di ambiente GOOGLE_GENAI_API_KEY sulla tua chiave API.

  • Specifica la chiave API quando inizilizi il plug-in:

    googleAI({ apiKey: yourKey });

    Tuttavia, non incorporare la chiave API direttamente nel codice. Utilizza questa funzionalità solo in combinazione con un servizio come Cloud Secret Manager o uno simile.

Utilizzo

Questo plug-in esporta in modo statico i riferimenti ai modelli supportati:

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

Puoi utilizzare questi riferimenti per specificare il modello utilizzato da generate():

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

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

o utilizzare componenti embed (ad es. textEmbedding004) con embed o cani da riporto:

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

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

API Gemini Files

Puoi utilizzare i file caricati nell'API Gemini Files con 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}}
  ]
});

Modelli ottimizzati

Puoi utilizzare i modelli ottimizzati con l'API Google Gemini. Segui le istruzioni dell'API Gemini o perfeziona un modello utilizzando AI Studio.

Il processo di ottimizzazione utilizza un modello di base, ad esempio Gemini 1.5 Flash, e gli esempi forniti per creare un nuovo modello ottimizzato. Ricorda il modello di base che hai utilizzato e copia l'ID del nuovo modello.

Quando chiami il modello ottimizzato in Genkit, utilizza il modello di base come parametro model e passa l'ID del modello ottimizzato all'interno del blocco config. Ad esempio, se hai utilizzato Gemini 1.5 Flash come modello di base e hai ottenuto l'ID modello tunedModels/my-example-model-apbm8oqbvuv2, puoi chiamarlo con:

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

Memorizzazione nella cache del contesto

Il plug-in di AI generativa di Google supporta la memorizzazione nella cache del contesto, che consente ai modelli di riutilizzare i contenuti memorizzati nella cache in precedenza per ottimizzare le prestazioni e ridurre la latenza per le attività ripetitive. Questa funzionalità è particolarmente utile per flussi di conversazione o scenari in cui il modello fa riferimento a un ampio testo in modo coerente in più richieste.

Come utilizzare la memorizzazione nella cache del contesto

Per attivare la memorizzazione nella cache del contesto, assicurati che il modello la supporti. Ad esempio, gemini15Flash e gemini15Pro sono modelli che supportano la memorizzazione nella cache del contesto.

Puoi definire un meccanismo di memorizzazione nella cache nella tua applicazione nel seguente modo:

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

In questa configurazione: - messages: consente di trasmettere la cronologia della conversazione. - metadata.cache.ttlSeconds: specifica il TTL (time-to-live) per la memorizzazione nella cache di una risposta specifica.

Esempio: sfruttare i testi di grandi dimensioni con il contesto

Per le applicazioni che fanno riferimento a documenti lunghi, come Guerra e pace o Il Signore degli Anelli, puoi strutturare le query per riutilizzare i contesti memorizzati nella 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.',
});

Memorizzazione nella cache di altre modalità di contenuti

I modelli Gemini sono multimodali e consentono di memorizzare nella cache anche altri tipi di contenuti.

Ad esempio, per memorizzare nella cache un lungo contenuto video, devi prima caricarlo utilizzando il file manager dell'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;

Ora puoi configurare la cache nelle chiamate a 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,
});

Modelli supportati per la memorizzazione nella cache del contesto

Solo modelli specifici, come gemini15Flash e gemini15Pro, supportano la memorizzazione nella cache del contesto. Se viene utilizzato un modello non supportato, verrà generato un errore che indica che la memorizzazione nella cache non può essere applicata.

Per approfondire

Per ulteriori informazioni sulla memorizzazione nella cache del contesto nell'AI di Google, consulta la relativa documentazione.