Wtyczka Vertex AI

Wtyczka Vertex AI udostępnia interfejsy do kilku usług AI:

Instalacja

npm i --save @genkit-ai/vertexai

Jeśli chcesz lokalnie uruchamiać przepływy, które korzystają z tej wtyczki, musisz też mieć zainstalowane narzędzie Google Cloud CLI.

Konfiguracja

Aby użyć tej wtyczki, określ ją podczas inicjowania Genkit:

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

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

Aby użyć wtyczki, musisz podać identyfikator projektu Google Cloud, region, w którym chcesz wysyłać żądania do interfejsu Vertex API, oraz dane logowania do projektu Google Cloud.

  • Identyfikator projektu Google Cloud możesz podać, ustawiając wartość projectId w konfiguracji vertexAI() lub ustawiając zmienną środowiskową GCLOUD_PROJECT. Jeśli uruchamiasz przepływ z otoczenia Google Cloud (np. Cloud Functions czy Cloud Run), zmienna GCLOUD_PROJECT jest automatycznie ustawiana na identyfikator projektu tego środowiska.
  • Lokalizację interfejsu API możesz określić, ustawiając wartość location w konfiguracji vertexAI() lub zmienną środowiskową GCLOUD_LOCATION.

  • Aby podać dane logowania do interfejsu API, musisz skonfigurować domyślne dane logowania do aplikacji Google Cloud.

    1. Aby określić swoje dane uwierzytelniające:

      • Jeśli uruchamiasz przepływ z środowiska Google Cloud (Cloud Functions, Cloud Run itp.), ta wartość jest ustawiana automatycznie.

      • W lokalnym środowisku programistycznym wykonaj te czynności:

        gcloud auth application-default login

      • W przypadku innych środowisk zapoznaj się z dokumentacją dotyczącą domyślnego uwierzytelniania aplikacji.

    2. Sprawdź też, czy do konta przypisana jest rola uprawnień Użytkownik Vertex AI (roles/aiplatform.user). Zapoznaj się z dokumentacją dotyczącą kontroli dostępu w Vertex AI.

Wykorzystanie

Modele generatywnej AI

Ta wtyczka eksportuje statycznie odwołania do obsługiwanych modeli generatywnej AI:

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

Za pomocą tych odwołań możesz określić, którego modelu używa funkcja ai.generate():

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

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

Ten wtyczek obsługuje też osadzanie odpowiedzi tekstowych Gemini za pomocą wyszukiwarki Google lub własnych danych.

Przykład:

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

Ten wtyczka eksportuje też statycznie odwołanie do modelu wklejania tekstu Gecko:

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

Za pomocą tego odwołania możesz określić, którego wstawiacza używa indeksator lub pobieracz. Jeśli na przykład używasz Chroma DB:

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

Możesz też utworzyć kod embed bezpośrednio:

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

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

Model Imagen3 umożliwia generowanie obrazów na podstawie prompta użytkownika:

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();

i nawet zaawansowana edycja istniejących obrazów:

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();

Więcej informacji znajdziesz w dokumentacji modelu ImageNet.

Anthropic Claude 3 w bazie modeli Vertex AI

Jeśli masz dostęp do modeli Claude 3 (haiku, sonnet lub opus) w bazie modeli Vertex AI, możesz ich używać w Genkit.

Oto przykładowa konfiguracja umożliwiająca korzystanie z modeli z bazy modeli Vertex AI:

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

Następnie użyj ich jako zwykłych modeli:

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

Llama 3.1 405b w bazie modeli Vertex AI

Najpierw musisz włączyć usługę Llama 3.1 API w bazie modeli Vertex AI.

Przykładowa konfiguracja Llama 3.1 405b we wtyczce Vertex AI:

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

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

Następnie możesz używać ich jak zwykłych modeli:

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

Oceniający

Aby używać oceniaczy z Rapid Evaluation w Vertex AI, dodaj blok evaluation do konfiguracji wtyczki vertexAI.

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

Konfiguracja powyżej dodaje oceniacze dla danych Safety i ROUGE. Przykład pokazuje 2 podejścia: dane Safety korzystają ze specyfikacji domyślnej, a dane ROUGE – ze specyfikacji niestandardowej, która ustawia typ błędu na rougeLsum.

Oba evaluatory można uruchomić za pomocą polecenia genkit eval:run z kompatybilnym zbiorem danych, czyli zbiorem danych z polami output i reference. Oceniacz Safety może też być uruchamiany za pomocą polecenia genkit eval:flow -e vertexai/safety, ponieważ wymaga tylko output.

Indeksatory i pobieranie

Wtyczka Genkit Vertex AI zawiera implementacje indeksatora i wyszukiwarki obsługiwane przez usługę wyszukiwania wektorowego Vertex AI.

(Aby dowiedzieć się, jak indeksatory i wyszukiwarki są używane w ramach implementacji RAG, przejdź na stronę generowania rozszerzonego przez wyszukiwanie w zapisanych informacjach).

Usługa Vertex AI Vector Search to indeks dokumentów, który działa razem z wybranym przez Ciebie magazynem dokumentów: magazyn dokumentów zawiera treść dokumentów, a indeks Vertex AI Vector Search zawiera dla każdego dokumentu jego wektorowe zakodowanie i odniesienie do dokumentu w magazynie dokumentów. Gdy dokumenty zostaną zindeksowane przez usługę Vertex AI Vector Search, będzie ona mogła odpowiadać na zapytania wyszukiwania, tworząc listy indeksów w Twoim magazynie dokumentów.

Implementacje indeksatora i wyszukiwacza udostępniane przez wtyczkę Vertex AI używają Cloud Firestore lub BigQuery jako magazynu dokumentów. Wtyczka zawiera też interfejsy, które możesz zaimplementować, aby obsługiwać inne repozytoria dokumentów.

Aby korzystać z wyszukiwania wektorowego w Vertex AI:

  1. Wybierz model wektora. Ten model odpowiada za tworzenie wektorów dystrybucyjnych na podstawie tekstu. Zaawansowani użytkownicy mogą używać modelu embeddingu zoptymalizowanego pod kątem ich konkretnych zbiorów danych, ale dla większości użytkowników model text-embedding-004 Vertex AI jest dobrym wyborem w przypadku tekstu w języku angielskim, a model text-multilingual-embedding-002 – w przypadku tekstu wielojęzycznego.

  2. W konsoli Google Cloud w sekcji Wyszukiwanie wektorów utwórz nowy indeks. Najważniejsze ustawienia to:

    • Wymiary: określ wymiary wektorów wygenerowanych przez wybrany model embeddingu. Modele text-embedding-004 i text-multilingual-embedding-002 generują wektory o 768 wymiarach.
    • Metoda aktualizacji: wybierz aktualizacje strumieniowe.

    Po utworzeniu indeksu wdróż go w standardowym (publicznym) punkcie końcowym.

  3. Pobierz indeksator i odzyskiwacz dokumentów dla magazynu dokumentów, którego chcesz użyć:

    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);

    Inne

    Aby obsługiwać inne repozytoria dokumentów, możesz udostępnić własne implementacje interfejsów DocumentRetriever i DocumentIndexer:

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

    Przykładem jest przykładowy moduł wyodrębniania i indeksowania za pomocą wtyczki Vertex AI z plikiem lokalnym.

  4. Dodaj blok vectorSearchOptions do konfiguracji wtyczki vertexAI:

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

    Podaj wtyczkę wybraną w pierwszym kroku oraz indeksator i pobierający dokumenty utworzone w poprzednim kroku.

    Aby skonfigurować wtyczkę tak, aby korzystała z utworzonego wcześniej indeksu wyszukiwania wektorowego, musisz podać kilka wartości, które znajdziesz w sekcji wyszukiwania wektorowego w konsoli Google Cloud:

    • indexId: wymienione na karcie Indeksy
    • indexEndpointId: wymienione na karcie Punkty końcowe indeksu
    • deployedIndexId i publicDomainName: znajdują się na stronie „Informacje o wdrożonym indeksie”, którą możesz otworzyć, klikając nazwę wdrożonego indeksu na jednej z wymienionych wcześniej kart.

  5. Gdy wszystko jest skonfigurowane, możesz używać indeksatora i wyszukiwarki w aplikacji Genkit:

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

Zobacz przykłady kodu dotyczące: