Plug-in da IA generativa do Google

O plug-in da IA generativa do Google fornece interfaces para os modelos do Gemini do Google pela API Gemini.

Instalação

npm i --save @genkit-ai/googleai

Configuração

Para usar esse plug-in, especifique-o ao inicializar o Genkit:

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

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

O plug-in exige uma chave de API para a API Gemini, que você pode acessar no Google AI Studio.

Siga um destes procedimentos para configurar o plug-in para usar sua chave de API:

  • Defina a variável de ambiente GOOGLE_GENAI_API_KEY como sua chave de API.

  • Especifique a chave de API ao inicializar o plug-in:

    googleAI({ apiKey: yourKey });

    No entanto, não incorpore a chave de API diretamente no código. Use este recurso apenas em conjunto com um serviço como o Cloud Secret Manager ou similar.

Uso

Esse plug-in exporta estaticamente referências aos modelos compatíveis:

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

Você pode usar essas referências para especificar qual modelo generate() usa:

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

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

ou use embedders (por exemplo, textEmbedding004) com embed ou retrievers:

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

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

API Gemini Files

É possível usar arquivos enviados para a API Gemini Files com o 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}}
  ]
});

Modelos ajustados

É possível usar modelos ajustados com a API Google Gemini. Siga as instruções da API Gemini ou ajuste um modelo usando o AI Studio.

O processo de ajuste usa um modelo base, por exemplo, o Gemini 1.5 Flash, e seus exemplos fornecidos para criar um novo modelo ajustado. Lembre-se do modelo de base que você usou e copie o ID do novo modelo.

Ao chamar o modelo ajustado no Genkit, use o modelo base como o parâmetro model e transmita o ID do modelo ajustado como parte do bloco config. Por exemplo, se você usou o Gemini 1.5 Flash como modelo base e recebeu o ID do modelo tunedModels/my-example-model-apbm8oqbvuv2, é possível fazer a chamada com:

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

Armazenamento em cache de contexto

O plug-in da IA generativa do Google oferece suporte ao armazenamento em cache de contexto, que permite que os modelos reutilizem o conteúdo armazenado em cache anteriormente para otimizar o desempenho e reduzir a latência em tarefas repetitivas. Esse recurso é especialmente útil para fluxos de conversa ou cenários em que o modelo faz referência a um grande volume de texto de forma consistente em várias solicitações.

Como usar o armazenamento em cache de contexto

Para ativar o armazenamento em cache de contexto, verifique se o modelo oferece suporte a ele. Por exemplo, gemini15Flash e gemini15Pro são modelos compatíveis com o armazenamento em cache de contexto.

É possível definir um mecanismo de armazenamento em cache no app desta forma:

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

Nessa configuração: - messages: permite transmitir o histórico de conversas. - metadata.cache.ttlSeconds: especifica o time to live (TTL) para armazenar uma resposta específica em cache.

Exemplo: como usar textos grandes com contexto

Para aplicativos que fazem referência a documentos longos, como Guerra e Paz ou O Senhor dos Anéis, é possível estruturar as consultas para reutilizar contextos em 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.',
});

Como armazenar outros modos de conteúdo em cache

Os modelos do Gemini são multimodais, e outros modos de conteúdo também podem ser armazenados em cache.

Por exemplo, para armazenar em cache um conteúdo de vídeo longo, primeiro faça o upload usando o gerenciador de arquivos do SDK de IA do Google:

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;

Agora você pode configurar o cache nas chamadas para 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,
});

Modelos com suporte para armazenamento em cache de contexto

Somente modelos específicos, como gemini15Flash e gemini15Pro, são compatíveis com o armazenamento em cache de contexto. Se um modelo sem suporte for usado, um erro será gerado, indicando que o armazenamento em cache não pode ser aplicado.

Leitura adicional

Confira mais informações sobre o armazenamento em cache de contexto na documentação da Google AI.