Vertex AI-Plug-in

Das Vertex AI-Plug-in bietet Schnittstellen zu mehreren KI-Diensten:

• Generative KI-Modelle von Google:
  • Gemini-Textgenerierung
  • Imagen2-Bildgenerierung
  • Generierung von Texteinbettungen
• Einige Bewertungsmesswerte über die Rapid Evaluation API von Vertex AI:
  • BLEU
  • ROUGE
  • Sprachkompetenz
  • Sicherheit
  • Fundierung
  • Qualität der Zusammenfassung
  • Nützlichkeit der Zusammenfassung
  • Ausführlichkeit der Zusammenfassung
• Vektorsuche

Installation

npm i --save @genkit-ai/vertexai

Wenn Sie Workflows, die dieses Plug-in verwenden, lokal ausführen möchten, muss außerdem das Google Cloud CLI-Tool installiert sein.

Konfiguration

Wenn Sie dieses Plug-in verwenden möchten, geben Sie es an, wenn Sie Genkit initialisieren:

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

const ai = genkit({
  plugins: [
    vertexAI({ location: 'us-central1' }),
  ],
});

Sie müssen die Google Cloud-Projekt-ID, die Region, an die Vertex API-Anfragen gesendet werden sollen, und die Anmeldedaten für Ihr Google Cloud-Projekt angeben.

• Sie können Ihre Google Cloud-Projekt-ID entweder durch Festlegen von projectId in der vertexAI()-Konfiguration oder durch Festlegen der Umgebungsvariablen GCLOUD_PROJECT angeben. Wenn Sie Ihren Ablauf in einer Google Cloud-Umgebung (z. B. Cloud Functions oder Cloud Run) ausführen, wird GCLOUD_PROJECT automatisch auf die Projekt-ID der Umgebung festgelegt.
• Sie können den API-Speicherort entweder durch Festlegen von location in der vertexAI()-Konfiguration oder durch Festlegen der Umgebungsvariablen GCLOUD_LOCATION angeben.

• Wenn Sie API-Anmeldedaten angeben möchten, müssen Sie die Standardanmeldedaten für Google Cloud-Anwendungen einrichten.

  1. So geben Sie Ihre Anmeldedaten an:

     • Wenn Sie Ihren Ablauf in einer Google Cloud-Umgebung (z. B. Cloud Functions oder Cloud Run) ausführen, wird dies automatisch festgelegt.

     • Führen Sie dazu in Ihrer lokalen Entwicklungsumgebung Folgendes aus:

       gcloud auth application-default login

     • Informationen zu anderen Umgebungen finden Sie in der Dokumentation zu Standardanmeldedaten für Anwendungen.

  2. Außerdem muss dem Konto die IAM-Rolle „Vertex AI-Nutzer“ (roles/aiplatform.user) zugewiesen sein. Weitere Informationen finden Sie in der Dokumentation zur Zugriffssteuerung in Vertex AI.

Nutzung

Generative AI-Modelle

Dieses Plug-in exportiert statisch Verweise auf die unterstützten Modelle für die generative KI:

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

Mit diesen Referenzen können Sie angeben, welches Modell für ai.generate() verwendet wird:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

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

Dieses Plug-in unterstützt auch die Fundierung von Gemini-Textantworten mithilfe der Google Suche oder Ihrer eigenen Daten.

Wichtig :Für Anfragen zur Begründung wird in Vertex AI zusätzlich zu den Kosten für LLM-Anfragen eine Gebühr erhoben. Lesen Sie die Seite Preise für Vertex AI und machen Sie sich mit den Preisen für Anfragen zur Standortbestimmung vertraut, bevor Sie diese Funktion verwenden.

Beispiel:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

await ai.generate({
  model: gemini15Flash,
  prompt: '...',
  config: {
    googleSearchRetrieval: {
      disableAttribution: true,
    }
    vertexRetrieval: {
      datastore: {
        projectId: 'your-cloud-project',
        location: 'us-central1',
        collection: 'your-collection',
      },
      disableAttribution: true,
    }
  }
})

Dieses Plug-in exportiert auch statisch einen Verweis auf das Gecko-Texteinbettungsmodell:

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

Mit dieser Referenz kannst du angeben, welchen Embedder ein Indexierer oder Retriever verwendet. Wenn du beispielsweise Chroma DB verwendest:

const ai = genkit({
  plugins: [
    chroma([
      {
        embedder: textEmbedding004,
        collectionName: 'my-collection',
      },
    ]),
  ],
});

Du kannst auch direkt ein Embed generieren:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const embedding = await ai.embed({
  embedder: textEmbedding004,
  content: 'How many widgets do you have in stock?',
});

Mit dem Imagen3-Modell können Bilder aus Nutzerprompts generiert werden:

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

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const response = await ai.generate({
  model: imagen3,
  output: { format: 'media' },
  prompt: 'a banana riding a bicycle',
});

return response.media();

und sogar die erweiterte Bearbeitung vorhandener Bilder:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const baseImg = fs.readFileSync('base.png', { encoding: 'base64' });
const maskImg = fs.readFileSync('mask.png', { encoding: 'base64' });

const response = await ai.generate({
  model: imagen3,
  output: { format: 'media' },
  prompt: [
    { media: { url: `data:image/png;base64,${baseImg}` }},
    {
      media: { url: `data:image/png;base64,${maskImg}` },
      metadata: { type: 'mask' },
    },
    { text: 'replace the background with foo bar baz' },
  ],
  config: {
    editConfig: {
      editMode: 'outpainting',
    },
  },
});

return response.media();

Weitere Informationen finden Sie in der Dokumentation zum Bildmodell.

Anthropic Claude 3 in Vertex AI Model Garden

Wenn Sie im Vertex AI Model Garden Zugriff auf Claude 3-Modelle (Haiku, Sonett oder Opus) haben, können Sie sie mit Genkit verwenden.

Hier ist eine Beispielkonfiguration zum Aktivieren von Vertex AI Model Garden-Modellen:

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

const ai = genkit({
  plugins: [
    vertexAIModelGarden({
      location: 'us-central1',
      models: [claude3Haiku, claude3Sonnet, claude3Opus],
    }),
  ],
});

Verwenden Sie sie dann wie normale Modelle:

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

Llama 3.1 405b im Vertex AI Model Garden

Sie müssen zuerst den Llama 3.1 API-Dienst in Vertex AI Model Garden aktivieren.

Hier ist eine Beispielkonfiguration für Llama 3.1 405b im Vertex AI-Plug-in:

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

const ai = genkit({
  plugins: [
    vertexAIModelGarden({
      location: 'us-central1',
      models: [llama31],
    }),
  ],
});

Verwenden Sie sie dann wie normale Modelle:

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

Evaluators

Wenn Sie die Bewertungsmethoden von Vertex AI Rapid Evaluation verwenden möchten, fügen Sie Ihrer vertexAI-Plug-in-Konfiguration einen evaluation-Block hinzu.

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

const ai = genkit({
  plugins: [
    vertexAIEvaluation({
      location: 'us-central1',
      metrics: [
        VertexAIEvaluationMetricType.SAFETY,
        {
          type: VertexAIEvaluationMetricType.ROUGE,
          metricSpec: {
            rougeType: 'rougeLsum',
          },
        },
      ],
    }),
  ],
});

In der obigen Konfiguration werden Evaluatoren für die Messwerte Safety und ROUGE hinzugefügt. Das Beispiel zeigt zwei Ansätze: Beim Messwert Safety wird die Standardspezifikation verwendet, während der Messwert ROUGE eine benutzerdefinierte Spezifikation enthält, die den Rogue-Typ auf rougeLsum festlegt.

Beide Bewertungstools können mit dem Befehl genkit eval:run und einem kompatiblen Dataset ausgeführt werden, also einem Dataset mit den Feldern output und reference. Der Safety-Evaluator kann auch mit dem Befehl genkit eval:flow -e vertexai/safety ausgeführt werden, da er nur eine output benötigt.

Indexierungs- und Abrufprogramme

Das Genkit Vertex AI-Plug-in enthält Indexierungs- und Abrufimplementierungen, die vom Vertex AI Vector Search-Dienst unterstützt werden.

Auf der Seite Retrieval Augmented Generation erfahren Sie, wie Indexer und Retriever in einer RAG-Implementierung verwendet werden.

Der Vertex AI Vector Search-Dienst ist ein Dokumentindex, der mit dem Dokumentspeicher Ihrer Wahl zusammenarbeitet: Der Dokumentspeicher enthält den Inhalt der Dokumente und der Vertex AI Vector Search-Index enthält für jedes Dokument die Vektoreinbettung und einen Verweis auf das Dokument im Dokumentspeicher. Nachdem Ihre Dokumente vom Vertex AI Vector Search-Dienst indexiert wurden, kann er auf Suchanfragen antworten und Listen von Indexen in Ihrem Dokumentenspeicher erstellen.

Die vom Vertex AI-Plug-in bereitgestellten Indexierungs- und Abrufimplementierungen verwenden entweder Cloud Firestore oder BigQuery als Dokumentenspeicher. Das Plug-in enthält auch Schnittstellen, die Sie implementieren können, um andere Dokumentenspeicher zu unterstützen.

Wichtig :Die Preise für die Vektorsuche umfassen sowohl eine Gebühr für jedes Gigabyte der aufgenommenen Daten als auch eine stündliche Gebühr für die VMs, auf denen Ihre bereitgestellten Indexe gehostet werden. Weitere Informationen finden Sie unter Vertex AI-Preise. Dies ist wahrscheinlich am kostengünstigsten, wenn Sie große Mengen an Traffic verarbeiten. Informieren Sie sich über die Auswirkungen des Dienstes auf die Abrechnung Ihres Projekts, bevor Sie ihn verwenden.

So verwenden Sie die Vertex AI-Vektorsuche:

1. Wählen Sie ein Einbettungsmodell aus. Dieses Modell ist für die Erstellung von Vektoreinbettungen aus Text verantwortlich. Fortgeschrittene Nutzer können ein für ihre spezifischen Datensätze optimiertes Einbettungsmodell verwenden. Für die meisten Nutzer ist das text-embedding-004-Modell von Vertex AI jedoch eine gute Wahl für englischsprachigen Text und das text-multilingual-embedding-002-Modell für mehrsprachigen Text.

2. Erstellen Sie in der Google Cloud Console im Bereich Vektorsuche einen neuen Index. Die wichtigsten Einstellungen sind:

   • Dimensionen:Geben Sie die Dimension der Vektoren an, die vom ausgewählten Einbettungsmodell erstellt werden. Die Modelle text-embedding-004 und text-multilingual-embedding-002 generieren Vektoren mit 768 Dimensionen.
   • Aktualisierungsmethode:Wählen Sie „Streaming-Updates“ aus.

   Nachdem Sie den Index erstellt haben, stellen Sie ihn auf einem Standard- (öffentlichen) Endpunkt bereit.

3. Holen Sie sich einen Dokumentindexierer und -abrufer für den gewünschten Dokumentspeicher:

   Cloud Firestore

   import { getFirestoreDocumentIndexer, getFirestoreDocumentRetriever } from '@genkit-ai/vertexai/vectorsearch';
   
   import { initializeApp } from 'firebase-admin/app';
   import { getFirestore } from 'firebase-admin/firestore';
   
   initializeApp({ projectId: PROJECT_ID });
   const db = getFirestore();
   
   const firestoreDocumentRetriever = getFirestoreDocumentRetriever(db, FIRESTORE_COLLECTION);
   const firestoreDocumentIndexer = getFirestoreDocumentIndexer(db, FIRESTORE_COLLECTION);
   

   BigQuery

   import { getBigQueryDocumentIndexer, getBigQueryDocumentRetriever } from '@genkit-ai/vertexai/vectorsearch';
   import { BigQuery } from '@google-cloud/bigquery';
   
   const bq = new BigQuery({ projectId: PROJECT_ID });
   
   const bigQueryDocumentRetriever = getBigQueryDocumentRetriever(bq, BIGQUERY_TABLE, BIGQUERY_DATASET);
   const bigQueryDocumentIndexer = getBigQueryDocumentIndexer(bq, BIGQUERY_TABLE, BIGQUERY_DATASET);
   

   Sonstiges

   Wenn Sie andere Dokumentenspeicher unterstützen möchten, können Sie Ihre eigenen Implementierungen von DocumentRetriever und DocumentIndexer bereitstellen:

   const myDocumentRetriever = async (neighbors) => {
     // Return the documents referenced by `neighbors`.
     // ...
   }
   const myDocumentIndexer = async (documents) => {
     // Add `documents` to storage.
     // ...
   }
   

   Ein Beispiel finden Sie unter Beispiel für einen Vertex AI-Plug-in-Abruf- und Indexierungsmechanismus mit lokaler Datei.

4. Fügen Sie der vertexAI-Plug-in-Konfiguration einen vectorSearchOptions-Block hinzu:

   import { genkit } from 'genkit';
   import { textEmbedding004 } from '@genkit-ai/vertexai';
   import { vertexAIVectorSearch } from '@genkit-ai/vertexai/vectorsearch';
   
   const ai = genkit({
     plugins: [
       vertexAIVectorSearch({
         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,
           },
         ],
       }),
     ],
   });
   

   Geben Sie den im ersten Schritt ausgewählten Embedder sowie den im vorherigen Schritt erstellten Dokumentindexierer und -abrufer an.

   Wenn Sie das Plug-in so konfigurieren möchten, dass es den zuvor erstellten Vektorsuchindex verwendet, müssen Sie mehrere Werte angeben. Diese finden Sie in der Google Cloud Console im Bereich „Vektorsuche“:

   • indexId: auf dem Tab Indexe aufgeführt sind
   • indexEndpointId: auf dem Tab Indexendpunkte aufgeführt sind
   • deployedIndexId und publicDomainName: Auf der Seite „Bereitgestellte Indexinformationen“ aufgeführt. Sie können sie öffnen, indem Sie auf einem der oben genannten Tabs auf den Namen des bereitgestellten Index klicken.

5. Nachdem alles konfiguriert ist, können Sie den Indexer und Retriever in Ihrer Genkit-Anwendung verwenden:

   import {
     vertexAiIndexerRef,
     vertexAiRetrieverRef,
   } from '@genkit-ai/vertexai/vectorsearch';
   
   // ... inside your flow function:
   
   await ai.index({
     indexer: vertexAiIndexerRef({
       indexId: VECTOR_SEARCH_INDEX_ID,
     }),
     documents,
   });
   
   const res = await ai.retrieve({
     retriever: vertexAiRetrieverRef({
       indexId: VECTOR_SEARCH_INDEX_ID,
     }),
     query: queryDocument,
   });
   

Hier finden Sie Codebeispiele für:

• Vertex Vector Search + BigQuery
• Vertex Vector Search + Firestore
• Vertex-Vektorsuche und benutzerdefinierte Datenbank