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 wywołania funkcji 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.

  • 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 ze środowiska Google Cloud (Cloud Funkcje, Cloud Run itp.), w polu GCLOUD_PROJECT jest automatycznie ustawiona wartość identyfikator projektu środowiska.

  • Lokalizację interfejsu API możesz określić, ustawiając wartość location w konfiguracji vertexAI() lub ustawiając zmienną środowiska GCLOUD_LOCATION.

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

    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 wykonaj te czynności:

      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 obsługuje też umocowanie odpowiedzi tekstowych Gemini za pomocą Wyszukiwarka Google lub własnych danych.

Przykład:

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

Ta wtyczka statycznie eksportuje też odniesienie do osadzania tekstu gekon 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',
      },
    ]),
  ],
});

Możesz też utworzyć kod embed 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?',
});

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

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

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

return response.media();

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.

Oto przykładowa konfiguracja włączania modeli z 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ę Llama 3.1 API 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',
            },
          },
        ],
      },
    }),
  ],
  // ...
});

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

Oba ewaluatory mogą być uruchamiane za pomocą polecenia genkit eval:run z kompatybilnym zbiorem danych, czyli zbiorem danych z pola 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 moduły pobierania są używane w implementacji RAG).

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, usługa ta może odpowiadać na zapytania wyszukiwania, tworząc listy indeksów w Twoim magazynie 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 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 umieszczania zoptymalizowanego dla konkretnych zbiorów danych. Jednak dla większości użytkowników Vertex AI 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 to:

    • Wymiary: określ wymiary wektorów wygenerowanych przez wybrany model osadzania. 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 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 repozytoria dokumentów, możesz udostępnić własne implementacje funkcji 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ładem jest przykładowy moduł wyodrębniania i indeksowania danych 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 wtyczkę do umieszczania, którą wybrałeś/wybrałaś w pierwszym kroku, oraz indeksator i odzyskiwacz dokumentów utworzone w poprzednim kroku.

    Aby skonfigurować wtyczkę do korzystania z utworzonego wcześniej indeksu wyszukiwania wektorowego, musisz podać kilka wartości, które znajdziesz w sekcji wyszukiwania wektorowego 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. Gdy wszystko jest skonfigurowane, zaimportuj odwołania do funkcji pobierania i indeksowania 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: