Complemento de Vertex AI

El complemento de Vertex AI proporciona interfaces para varios servicios de IA:

Instalación

npm i --save @genkit-ai/vertexai

Si quieres ejecutar localmente flujos que usan este complemento, también necesitas el Tener instalada la herramienta Google Cloud CLI

Configuración

Para usar este complemento, especifícalo cuando llames a configureGenkit():

import { vertexAI } from '@genkit-ai/vertexai';

export default configureGenkit({
  plugins: [
    vertexAI({ projectId: 'your-cloud-project', location: 'us-central1' }),
  ],
  // ...
});

El complemento requiere que especifiques el ID del proyecto de Google Cloud, la región a la que deseas realizar solicitudes a la API de Vertex y las credenciales de tu proyecto de Google Cloud.

  • Puedes especificar el ID del proyecto de Google Cloud configurando projectId en la configuración de vertexAI() o mediante el entorno de GCLOUD_PROJECT de salida. Si ejecutas tu flujo desde un entorno de Google Cloud (Cloud Cloud Functions, Cloud Run, etc.), GCLOUD_PROJECT se establece automáticamente en el ID de proyecto del entorno.

  • Puedes especificar la ubicación de la API configurando location en Configuración de vertexAI() o del entorno GCLOUD_LOCATION de salida.

  • Para proporcionar las credenciales de la API, debes configurar las credenciales predeterminadas de la aplicación de Google Cloud.

    1. Para especificar tus credenciales, haz lo siguiente:

      • Si ejecutas tu flujo desde un entorno de Google Cloud (Cloud Functions, Cloud Run, etc.), esto se configura automáticamente.

      • En tu entorno de desarrollo local, ejecuta el siguiente comando:

      gcloud auth application-default login

    2. Además, asegúrate de que la cuenta tenga el rol de IAM Usuario de Vertex AI (roles/aiplatform.user). Consulta los documentos de control de acceso de Vertex AI.

Uso

Modelos de IA generativa

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

import { gemini15Flash, gemini15Pro, imagen2 } from '@genkit-ai/vertexai';

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

const llmResponse = await generate({
  model: gemini15Flash,
  prompt: 'What should I do when I visit Melbourne?',
});

Este complemento también exporta estáticamente una referencia a la incorporación de texto de Gecko. modelo:

import { textEmbeddingGecko } from '@genkit-ai/vertexai';

Puedes usar esta referencia para especificar qué embedder, un indexador o un retriever que la API usa. Por ejemplo, si usas Chroma DB:

configureGenkit({
  plugins: [
    chroma([
      {
        embedder: textEmbeddingGecko,
        collectionName: 'my-collection',
      },
    ]),
  ],
});

También puedes generar una incorporación directamente:

// import { embed, EmbedderArgument } from '@genkit-ai/ai/embedder';
const embedding = await embed({
  embedder: textEmbeddingGecko,
  content: 'How many widgets do you have in stock?',
});

Anthropic Claude 3 en Model Garden de Vertex AI

Si tienes acceso a modelos de Claude 3 (haiku, sonnet u opus) en Model Garden de Vertex AI, puedes usarlos con Genkit.

Esta es una configuración de muestra para habilitar los modelos de Model Garden de Vertex AI:

import {
  vertexAI,
  claude3Haiku,
  claude3Sonnet,
  claude3Opus,
} from '@genkit-ai/vertexai';

export default configureGenkit({
  plugins: [
    vertexAI({
      location: 'us-central1',
      modelGarden: {
        models: [claude3Haiku, claude3Sonnet, claude3Opus],
      },
    }),
  ],
});

Luego, úsalos como modelos normales:

const llmResponse = await generate({
  model: claude3Sonnet,
  prompt: 'What should I do when I visit Melbourne?',
});

Llama 3.1 405b en Model Garden de Vertex AI

Primero, deberás habilitar el servicio de la API de Llama 3.1 en Model Garden de Vertex AI.

A continuación, se muestra una configuración de muestra para Llama 3.1 405b en el complemento de Vertex AI:

import { vertexAI, llama31 } from '@genkit-ai/vertexai';

export default configureGenkit({
  plugins: [
    vertexAI({
      location: 'us-central1',
      modelGarden: {
        models: [llama31],
      },
    }),
  ],
});

Luego, úsalo como modelos normales:

const llmResponse = await generate({
  model: llama31,
  prompt: 'Write a function that adds two numbers together',
});

Evaluadores

Para usar los evaluadores de la evaluación rápida de Vertex AI, agrega un bloque evaluation a la configuración del complemento vertexAI.

import { vertexAI, VertexAIEvaluationMetricType } from '@genkit-ai/vertexai';

export default configureGenkit({
  plugins: [
    vertexAI({
      projectId: 'your-cloud-project',
      location: 'us-central1',
      evaluation: {
        metrics: [
          VertexAIEvaluationMetricType.SAFETY,
          {
            type: VertexAIEvaluationMetricType.ROUGE,
            metricSpec: {
              rougeType: 'rougeLsum',
            },
          },
        ],
      },
    }),
  ],
  // ...
});

La configuración anterior agrega evaluadores para las métricas Safety y ROUGE. En el ejemplo, se muestran dos enfoques: la métrica Safety usa la especificación predeterminada, mientras que la métrica ROUGE proporciona una especificación personalizada que establece el tipo de marcador en rougeLsum.

Ambos evaluadores se pueden ejecutar con el comando genkit eval:run con un conjunto de datos compatible, es decir, un conjunto de datos con los campos output y reference. El evaluador Safety también se puede ejecutar con el comando genkit eval:flow -e vertexai/safety, ya que solo requiere un output.

Indexadores y recuperadores

El complemento Genkit de Vertex AI incluye implementaciones de indexador y recuperador respaldadas por el servicio de búsqueda de vectores de Vertex AI.

Consulta la página sobre la generación aumentada de recuperación para descubrir cómo los indexadores. y los retrievers se usan en una implementación RAG).

El servicio de búsqueda de vectores de Vertex AI es un índice de documentos que funciona con el de documentos que elijas: contiene el contenido de y el índice de Vertex AI Vector Search contiene, para cada documento, su incorporación vectorial y una referencia al documento en el almacén. Después de que el servicio de búsqueda de vectores de Vertex AI indexe tus documentos, podrá responder a las búsquedas y generar listas de índices en tu almacén de documentos.

Las implementaciones del indexador y del retriever que proporciona el complemento de Vertex AI usan ya sea Cloud Firestore o BigQuery como almacén de documentos. El complemento también incluye interfaces que puedes implementar para admitir otros almacenes de documentos.

Sigue estos pasos para usar la búsqueda de vectores de Vertex AI:

  1. Elige un modelo de incorporación. Este modelo es responsable de crear imágenes incorporaciones a partir de texto. Los usuarios avanzados pueden usar un modelo de incorporación optimizado para sus conjuntos de datos particulares, pero, para la mayoría de los usuarios, El modelo text-embedding-004 es una buena opción para el texto en inglés y las El modelo text-multilingual-embedding-002 es bueno para texto multilingüe.

  2. En la Búsqueda de vectores de la consola de Google Cloud, crea un índice nuevo. Lo más importante configuración son las siguientes:

    • Dimensiones: Especifica la dimensionalidad de los vectores que produce tu modelo de incorporación elegido. Los operadores text-embedding-004 y Los modelos de text-multilingual-embedding-002 producen vectores de 768 dimensiones.

    • Método de actualización: Selecciona las actualizaciones de transmisión.

    Después de crear el índice, impleméntalo en un extremo estándar (público).

  3. Obtén un indexador y un retriever de documentos para el almacén de documentos que quieres usar:

    Cloud Firestore

    import {
  getFirestoreDocumentIndexer,
  getFirestoreDocumentRetriever
} from '@genkit-ai/vertexai';

import { initializeApp } from 'firebase-admin/app';
import { getFirestore } from 'firebase-admin/firestore';

initializeApp({ projectId: PROJECT_ID });
const db = getFirestore();

const firestoreDocumentRetriever: DocumentRetriever =
  getFirestoreDocumentRetriever(db, FIRESTORE_COLLECTION);
const firestoreDocumentIndexer: DocumentIndexer =
  getFirestoreDocumentIndexer(db, FIRESTORE_COLLECTION);

    BigQuery

    import {
  getBigQueryDocumentIndexer,
  getBigQueryDocumentRetriever,
} from '@genkit-ai/vertexai';
import { BigQuery } from '@google-cloud/bigquery';

const bq = new BigQuery({ projectId: PROJECT_ID });

const bigQueryDocumentRetriever: DocumentRetriever =
  getBigQueryDocumentRetriever(bq, BIGQUERY_TABLE, BIGQUERY_DATASET);
const bigQueryDocumentIndexer: DocumentIndexer =
  getBigQueryDocumentIndexer(bq, BIGQUERY_TABLE, BIGQUERY_DATASET);

    Otro

    Para admitir otros almacenes de documentos, puedes proporcionar tus propias implementaciones de DocumentRetriever y DocumentIndexer:

    const myDocumentRetriever: DocumentRetriever = async (neighbors: Neighbor[]) => {
  // Return the documents referenced by `neighbors`.
  // ...
}
const myDocumentIndexer: DocumentIndexer = async (documents: Document[]) => {
  // Add `documents` to storage.
  // ...
}

    Para ver un ejemplo, consulta Sample Vertex AI Plugin Retriever and Indexer with Local File.

  4. Agrega un bloque vectorSearchOptions a la configuración del complemento vertexAI:

    import { configureGenkit } from '@genkit-ai/core';
import { vertexAI, textEmbedding004 } from '@genkit-ai/vertexai';

configureGenkit({
  plugins: [
    vertexAI({
      projectId: PROJECT_ID,
      location: LOCATION,
      vectorSearchOptions: [
        {
          indexId: VECTOR_SEARCH_INDEX_ID,
          indexEndpointId: VECTOR_SEARCH_INDEX_ENDPOINT_ID,
          deployedIndexId: VECTOR_SEARCH_DEPLOYED_INDEX_ID,
          publicDomainName: VECTOR_SEARCH_PUBLIC_DOMAIN_NAME,
          documentRetriever: firestoreDocumentRetriever,
          documentIndexer: firestoreDocumentIndexer,
          embedder: textEmbedding004,
        },
      ],
    }),
  ],
});

    Proporciona la incorporación que elegiste en el primer paso y el indexador de documentos y el retriever que creaste en el paso anterior.

    Si deseas configurar el complemento para que use el índice de búsqueda de vectores que creaste anteriormente, haz lo siguiente: debes proporcionar varios valores, que puedes encontrar en la Búsqueda de vectores de la consola de Google Cloud:

    • indexId: Aparece en la pestaña Índices.
    • indexEndpointId: Aparece en la pestaña Extremos de índice.
    • deployedIndexId y publicDomainName: Aparecen en el índice implementado información" que puedes abrir haciendo clic en el nombre del índice implementado en cualquiera de las pestañas mencionadas anteriormente

  5. Ahora que todo está configurado, importa las referencias del indizador y recuperador del complemento:

    import {
  vertexAiIndexerRef,
  vertexAiRetrieverRef,
} from '@genkit-ai/vertexai';

    Pasa las referencias a index() y retrieve():

    await index({
  indexer: vertexAiIndexerRef({
    indexId: VECTOR_SEARCH_INDEX_ID,
  }),
  documents,
});

    const res = await retrieve({
  retriever: vertexAiRetrieverRef({
    indexId: VECTOR_SEARCH_INDEX_ID,
  }),
  query: queryDocument,
});

Consulta las muestras de código para obtener lo siguiente: