Vertex AI-Plug-in

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

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.

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 eine Referenz 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',
      },
    ]),
  ],
});

Alternativ kannst du ein Embed direkt 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 einem Nutzerprompt 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 in 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',
});

Mistral-Modelle im Vertex AI Model Garden

Wenn Sie im Vertex AI Model Garden Zugriff auf Mistral-Modelle (Mistral Large, Mistral Nemo oder Codestral) 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 {
  mistralLarge,
  mistralNemo,
  codestral,
  vertexAIModelGarden,
} from '@genkit-ai/vertexai/modelgarden';

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

Verwenden Sie sie dann wie normale Modelle:

const llmResponse = await ai.generate({
  model: mistralLarge,
  prompt: 'Write a function that adds two numbers together',
  config: {
    version: 'mistral-large-2411', // Optional: specify model version
    temperature: 0.7,              // Optional: control randomness (0-1)
    maxOutputTokens: 1024,         // Optional: limit response length
    topP: 0.9,                     // Optional: nucleus sampling parameter
    stopSequences: ['###'],        // Optional: stop generation at sequences
  }
});

Die Modelle unterstützen: - mistralLarge: Neuestes Mistral Large-Modell mit Funktionsaufruffunktionen - mistralNemo: Für Effizienz und Geschwindigkeit optimiert - codestral: Speziell für Codegenerierungsaufgaben

Jedes Modell unterstützt Streamingantworten und Funktionsaufrufe:

const response = await ai.generateStream({
  model: mistralLarge,
  prompt: 'What should I cook tonight?',
  tools: ['recipe-finder'],
  config: {
    version: 'mistral-large-2411',
    temperature: 1,
  },
});

for await (const chunk of response.stream) {
  console.log(chunk.text);
}

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, d. h. 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.

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:Hier 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:

Kontext-Caching

Das Vertex AI Genkit-Plug-in unterstützt das Kontext-Caching. So können Modelle zuvor im Cache gespeicherte Inhalte wiederverwenden, um die Tokennutzung bei großen Datenmengen zu optimieren. Diese Funktion ist besonders nützlich für Konversationsabläufe oder Szenarien, in denen das Modell in mehreren Anfragen konsistent auf einen großen Inhalt verweist.

Kontext-Caching verwenden

Damit das Kontext-Caching aktiviert werden kann, muss Ihr Modell diese Funktion unterstützen. gemini15Flash und gemini15Pro sind beispielsweise Modelle, die den Kontext-Cache unterstützen. Sie müssen dann die Versionsnummer 001 angeben.

So können Sie einen Caching-Mechanismus in Ihrer Anwendung definieren:

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,
  prompt: 'Describe Pierre’s transformation throughout the novel.',
});

Bei dieser Konfiguration: – messages: Sie können den Unterhaltungsverlauf übergeben. – metadata.cache.ttlSeconds: Gibt die Gültigkeitsdauer (TTL) für das Caching einer bestimmten Antwort an.

Beispiel: Lange Texte mit Kontext nutzen

Bei Anwendungen, die auf lange Dokumente verweisen, z. B. Krieg und Frieden oder Der Herr der Ringe, können Sie Ihre Abfragen so strukturieren, dass zwischengespeicherte Kontexte wiederverwendet werden:


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,
  prompt: 'Analyze the relationship between Pierre and Natasha.',
});

Vorteile des Kontext-Cachings

  1. Verbesserte Leistung: Die wiederholte Verarbeitung großer Eingaben wird reduziert.
  2. Kosteneffizienz: Die API-Nutzung für redundante Daten wird reduziert, wodurch der Tokenverbrauch optimiert wird.
  3. Niedrigere Latenz: Die Antwortzeiten für wiederholte oder ähnliche Abfragen werden beschleunigt.

Unterstützte Modelle für das Kontext-Caching

Nur bestimmte Modelle wie gemini15Flash und gemini15Pro unterstützen das Kontext-Caching und derzeit nur für Versionsnummern ab 001. Wenn ein nicht unterstütztes Modell verwendet wird, wird ein Fehler ausgegeben, der darauf hinweist, dass das Caching nicht angewendet werden kann.

Weiterführende Literatur

Weitere Informationen zum Kontext-Caching in Vertex AI finden Sie in der Dokumentation.