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 korzystające z tej wtyczki, musisz też dodać Zainstalowano narzędzie wiersza poleceń Google Cloud.

Konfiguracja

Aby używać tej wtyczki, określ ją, gdy wywołujesz configureGenkit():

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

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

Wtyczka wymaga podania identyfikatora projektu Google Cloud, region [region] do których chcesz wysyłać żądania do interfejsu Vertex API, a Twój projekt Google Cloud dane logowania.

  • Możesz określić identyfikator projektu Google Cloud przez ustawienie projectId w konfigurację vertexAI() lub przez ustawienie środowiska GCLOUD_PROJECT . Jeśli uruchamiasz przepływ ze środowiska Google Cloud (Cloud Funkcje, Cloud Run itp.), w polu GCLOUD_PROJECT jest automatycznie ustawiona wartość identyfikator projektu środowiska.

  • Możesz określić lokalizację interfejsu API poprzez ustawienie location w vertexAI() lub przez ustawienie środowiska GCLOUD_LOCATION .

  • Aby podać dane logowania do interfejsu API, musisz skonfigurować aplikację Google Cloud Domyślne dane logowania.

    1. Aby podać dane logowania:

      • Jeśli uruchamiasz przepływ ze środowiska Google Cloud (Cloud Functions, Cloud Run itd.), to ustawienie jest ustawiane automatycznie.

      • W lokalnym środowisku programistycznym uruchom to polecenie:

      gcloud auth application-default login

    2. Sprawdź też, czy do konta została przypisana rola użytkownika Vertex AI (roles/aiplatform.user). Zobacz kontrolę dostępu Vertex AI dokumenty.

Wykorzystanie

Modele generatywnej AI

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

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

Korzystając z tych odwołań, możesz określić, którego modelu używa generate():

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

Ta wtyczka statycznie eksportuje też odniesienie do osadzania tekstu geko model:

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

Za pomocą tego odwołania możesz określić, który komponent osadzający, a także używający narzędzi do pobierania, zastosowań. Jeśli na przykład używasz bazy danych Chroma:

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

Wektor dystrybucyjny możesz też wygenerować bezpośrednio:

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

Antropikalny 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 połączeniu z Genkit.

Przykładowa konfiguracja umożliwiająca włączanie modeli bazy modeli Vertex AI:

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

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

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

const llmResponse = await 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ę interfejsu API Llama 3.1 w bazie modeli Vertex AI.

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

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

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

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

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

Weryfikatorzy

Aby korzystać z weryfikatorów z Vertex AI Rapid Evaluation, dodaj blok evaluation do konfiguracji wtyczki 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',
            },
          },
        ],
      },
    }),
  ],
  // ...
});

Powyższa konfiguracja dodaje weryfikatora wskaźników Safety i ROUGE. Przykład pokazuje 2 podejścia – dane Safety korzystają ze specyfikacji domyślnej, a dane ROUGE zawierają specyfikację niestandardową, która ustawia typ wskaźnika na rougeLsum.

Oba weryfikatory można uruchomić za pomocą polecenia genkit eval:run ze zgodnym zbiorem danych, czyli ze zbiorem danych z polami output i reference. Weryfikator Safety można też uruchomić za pomocą polecenia genkit eval:flow -e vertexai/safety, ponieważ wymaga ono tylko output.

Moduły indeksujące i moduły do pobierania

Wtyczka Genkit Vertex AI zawiera implementacje indeksera i narzędzia do pobierania korzysta z usługi wyszukiwania wektorowego Vertex AI.

(Informacje o tym, jak roboty indeksujące mogą działać, znajdziesz na stronie Generowanie rozszerzonego przez wyszukiwanie a w implementacji RAG są używane.

Usługa wyszukiwania wektorowego Vertex AI to indeks dokumentów, który działa równolegle wybrany magazyn dokumentów: magazyn dokumentów zawiera treść dokumentów, a indeks wyszukiwania wektorowego Vertex AI zawiera dla każdego dokumentu i odwołania do dokumentu w magazynie dokumentów. Po zindeksowaniu dokumentów przez usługę Vertex AI Vector Search może w odpowiedzi na zapytania, tworząc listy indeksów do magazynu dokumentów.

Implementacje indeksowania i pobierania udostępniane przez wtyczkę Vertex AI używają Cloud Firestore lub BigQuery jako magazyn dokumentów. Wtyczka zawiera interfejsy, które można wdrożyć w celu obsługi innych magazynów dokumentów.

Aby użyć wyszukiwania wektorowego Vertex AI:

  1. Wybierz model wektora dystrybucyjnego. Ten model odpowiada za tworzenie wektorów wektory dystrybucyjne z tekstu. Zaawansowani użytkownicy mogą używać modelu umieszczania zoptymalizowanego dla konkretnych zbiorów danych. Jednak dla większości użytkowników Vertex AI Model text-embedding-004 to dobry wybór w przypadku tekstu w języku angielskim i Model text-multilingual-embedding-002 dobrze sprawdza się w przypadku tekstu wielojęzycznych.

  2. za pomocą Wyszukiwania wektorowego, konsoli Google Cloud, utwórz nowy indeks. Najważniejsze ustawienia:

    • Wymiary: określ wymiarowość wektorów tworzonych przez wybranego modelu umieszczania. text-embedding-004 i Modele text-multilingual-embedding-002 generują wektory 768 wymiarów.

    • Metoda aktualizacji: wybierz aktualizacje strumieniowe.

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

  3. Pobierz moduł indeksujący i pobierający dokumenty dla magazynu dokumentów, którego chcesz używać:

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

    Inne

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

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

    Przykład znajdziesz w artykule Przykładowe narzędzie do pobierania i indeksowania wtyczek Vertex AI z plikiem lokalnym.

  4. Dodaj blok vectorSearchOptions do konfiguracji wtyczki 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,
        },
      ],
    }),
  ],
});

    Podaj komponent do umieszczenia wybrany w pierwszym kroku oraz narzędzie indeksujące dokumenty oraz retrievera utworzonego w poprzednim kroku.

    Aby skonfigurować wtyczkę do korzystania z utworzonego wcześniej indeksu wyszukiwania wektorowego, Podaj kilka wartości, które znajdziesz w Wyszukiwarce wektorowej w konsoli Google Cloud:

    • indexId: dostępne na karcie Indeksy
    • indexEndpointId: wymienione na karcie Punkty końcowe indeksu
    • deployedIndexId i publicDomainName: wymienione w indeksie „Wdrożony indeks” info” stronę, którą można otworzyć, klikając nazwę wdrożonego indeksu na jednej ze wspomnianych wcześniej kart

  5. Wszystko jest już skonfigurowane, możesz więc przejść do pobierania programów do pobierania plików i odwołań do indeksujących z wtyczki:

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

    Przekaż odniesienia do index() i retrieve():

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

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

Zobacz przykładowe fragmenty kodu: