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 w ramach 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 pobierający. Jeśli na przykład używasz Chroma DB:

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

Możesz też wygenerować embeddingi bezpośrednio:

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

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

Ta wtyczka obsługuje też założenia multimodalne:

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

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

const embeddings = await ai.embed({
  embedder: multimodalEmbedding001,
  content: {
    content: [{
      "media": {
        "url": "gs://cloud-samples-data/generative-ai/video/pixel8.mp4",
        "contentType": "video/mp4"
      }
    }]
  }
});

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

a 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 włączania 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 użyj go jako zwykłego modelu:

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

Modele Mistral w bazie modeli Vertex AI

Jeśli masz dostęp do modeli Mistral (Mistral Large, Mistral Nemo lub Codestral) w bazie modeli Vertex AI, możesz ich używać w Genkit.

Oto przykładowa konfiguracja włączania modeli z bazy modeli Vertex AI:

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

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

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

Modele obsługują: - mistralLarge: najnowszy model Mistral Large z funkcjami wywołania funkcji - mistralNemo: zoptymalizowany pod kątem wydajności i szybkości - codestral: specjalistyczny do zadań związanych z generowaniem kodu

Każdy model obsługuje strumieniowe odpowiedzi i wywoływanie funkcji:

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

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 narzędzia do oceny 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 wyszukiwarki;

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, otwórz stronę Generowanie rozszerzone przez wyszukiwanie).

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 magazyny dokumentów.

Aby korzystać z wyszukiwania wektorowego w Vertex AI:

  1. Wybierz model wektora. Ten model odpowiada za tworzenie wektorów dystrybucyjnych z tekstu lub multimediów. 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, model text-multilingual-embedding-002 nadaje się do tekstu wielojęzycznego, a model multimodalEmbedding001 nadaje się do tekstu, obrazów i filmów.

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

    • Wymiary: określ wymiary wektorów generowanych przez wybrany model embeddingu. Modele text-embedding-004 i text-multilingual-embedding-002 generują wektory o 768 wymiarach. Model multimodalEmbedding001 może generować wektory o 128, 256, 512 lub 1408 wymiarach w przypadku tekstu i obrazu oraz o 1408 wymiarach w przypadku filmu.
    • Metoda aktualizacji: wybierz opcję aktualizacji strumieniowych.

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

  3. Pobierz indeksator i wyszukiwarkę 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ą 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. Teraz, 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:

Buforowanie kontekstu

Wtyczka Vertex AI Genkit obsługuje przechowywanie w pamięci podręcznej kontekstu, co pozwala modelom ponownie używać wcześniej zapisanych w pamięci podręcznej treści, aby zoptymalizować wykorzystanie tokenów w przypadku dużych fragmentów treści. Ta funkcja jest szczególnie przydatna w przypadku ścieżek konwersacyjnych lub scenariuszy, w których model konsekwentnie odwołuje się do dużej ilości treści w różnych żądaniach.

Jak korzystać z zapamiętywania kontekstu

Aby włączyć buforowanie kontekstu, upewnij się, że Twój model to obsługuje. Na przykład modele gemini15Flash i gemini15Pro obsługują buforowanie kontekstu, ale musisz podać numer wersji 001.

Mechanizm buforowania możesz zdefiniować w aplikacji w ten sposób:

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

W tej konfiguracji:messages: umożliwia przekazywanie historii rozmów. – metadata.cache.ttlSeconds: określa czas życia danych (TTL) dla pamięci podręcznej konkretnej odpowiedzi.

Przykład: wykorzystanie dużych tekstów z kontekstem

W przypadku aplikacji odwołujących się do długich dokumentów, takich jak Wojna i pokój czy Władca Pierścieni, możesz sformułować zapytania w taki sposób, aby ponownie używać kontekstów z pamięci podręcznej:


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

Zalety buforowania kontekstu

  1. Zwiększona wydajność: zmniejsza potrzebę wielokrotnego przetwarzania dużych danych wejściowych.
  2. Skuteczność kosztowa: zmniejsza wykorzystanie interfejsu API do redundantnych danych, optymalizując zużycie tokenów.
  3. Mniejsze opóźnienie: krótszy czas oczekiwania na odpowiedź w przypadku powtarzających się lub powiązanych zapytań.

Obsługiwane modele w przypadku buforowania kontekstu

Tylko niektóre modele, takie jak gemini15Flash i gemini15Pro, obsługują buforowanie kontekstu, i obecnie tylko w wersjach 001. Jeśli użyjesz nieobsługiwanego modelu, pojawi się błąd informujący, że nie można zastosować pamięci podręcznej.

Więcej informacji

Więcej informacji o zapamiętaniu kontekstu w Vertex AI znajdziesz w dokumentacji.