Complemento de IA generativa de Google

El complemento de IA generativa de Google proporciona interfaces para los modelos de Gemini de Google a través de la API de Gemini.

Instalación

npm i --save @genkit-ai/googleai

Configuración

Para usar este complemento, especifícalo cuando inicialices Genkit:

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

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

El complemento requiere una clave de API para la API de Gemini, que puedes obtener en Google AI Studio

Configura el complemento para usar tu clave de API mediante una de las siguientes acciones:

  • Establece la variable de entorno GOOGLE_GENAI_API_KEY en tu clave de API.

  • Especifica la clave de API cuando inicialices el complemento:

    googleAI({ apiKey: yourKey });

    Sin embargo, no incorpores tu clave de API directamente en el código. Usa solo esta función junto con un servicio como Cloud Secret Manager o uno similar.

Uso

Este complemento exporta de forma estática referencias a sus modelos compatibles:

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

Puedes usar estas referencias para especificar qué modelo usa generate():

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

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

o usar incorporaciones (p. ej., textEmbedding004) con embed o recuperadores:

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

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

API de Gemini Files

Puedes usar los archivos subidos a la API de 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}}
  ]
});

Modelos ajustados

Puedes usar modelos ajustados con la API de Google Gemini. Sigue las instrucciones de la API de Gemini o ajusta un modelo con AI Studio.

El proceso de ajuste usa un modelo base (por ejemplo, Gemini 1.5 Flash) y los ejemplos que proporcionaste para crear un modelo ajustado nuevo. Recuerda el modelo base que usaste y copia el ID del modelo nuevo.

Cuando llames al modelo ajustado en Genkit, usa el modelo base como el parámetro model y pasa el ID del modelo ajustado como parte del bloque config. Por ejemplo, si usaste Gemini 1.5 Flash como modelo base y obtuviste el ID del modelo tunedModels/my-example-model-apbm8oqbvuv2, puedes llamarlo con lo siguiente:

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

Almacenamiento en caché de contexto

El complemento de IA generativa de Google admite el almacenamiento en caché de contexto, que permite a los modelos volver a usar contenido almacenado en caché anteriormente para optimizar el rendimiento y reducir la latencia de las tareas repetitivas. Esta función es especialmente útil para flujos de conversación o situaciones en las que el modelo hace referencia a un gran cuerpo de texto de forma coherente en varias solicitudes.

Cómo usar el almacenamiento en caché de contexto

Para habilitar la caché de contexto, asegúrate de que tu modelo la admita. Por ejemplo, gemini15Flash y gemini15Pro son modelos que admiten el almacenamiento en caché de contexto.

Puedes definir un mecanismo de almacenamiento en caché en tu aplicación de la siguiente manera:

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

En esta configuración: - messages: Te permite pasar el historial de conversaciones. - metadata.cache.ttlSeconds: Especifica el tiempo de actividad (TTL) para almacenar en caché una respuesta específica.

Ejemplo: Aprovecha textos grandes con contexto

En el caso de las aplicaciones que hacen referencia a documentos largos, como Guerra y paz o El Señor de los Anillos, puedes estructurar tus consultas para volver a usar los contextos almacenados en caché:

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

Almacenamiento en caché de otros modos de contenido

Los modelos de Gemini son multimodales, y también se pueden almacenar en caché otros modos de contenido.

Por ejemplo, para almacenar en caché un contenido de video largo, primero debes subirlo con el administrador de archivos del SDK de 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;

Ahora puedes configurar la caché en tus llamadas 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,
});

Modelos compatibles con el almacenamiento en caché de contexto

Solo modelos específicos, como gemini15Flash y gemini15Pro, admiten la caché de contexto. Si se usa un modelo no compatible, se generará un error que indicará que no se puede aplicar el almacenamiento en caché.

Lecturas adicionales

Consulta más información sobre el almacenamiento en caché de contexto en Google AI en su documentación.