Wtyczka Vertex AI

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

• Modele generatywnej AI od Google:
  • Generowanie tekstu w Gemini
  • generowanie obrazów za pomocą modeli Imagen2 i Imagen3;
  • Generowanie wektorów tekstowych
• Podzbiór danych oceny w interfejsie Vertex AI Rapid Evaluation API:
  • BLEU
  • ROUGE
  • Płynność
  • Bezpieczeństwo
  • Zorientowanie na cele
  • Jakość streszczenia
  • Przydatność podsumowania
  • Szczegółowość podsumowywania
• Wyszukiwanie wektorowe

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 wtyczek 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 retriever. Jeśli na przykład używasz Chroma DB:

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

Możesz też wygenerować 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();

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

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

Oceniacze

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ście: dane Safety korzystają ze specyfikacji domyślnej, a dane ROUGE – ze specyfikacji niestandardowej, która ustawia typ rysunku 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, przejdź na stronę generowania rozszerzonego 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 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 generowanych 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 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ą 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:

• Vertex Vector Search + BigQuery
• Vertex Vector Search + Firestore
• Wyszukiwanie wektorowe w Vertex + niestandardowa baza danych

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, więc 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. Kosztowność: 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. Obecnie dotyczy to tylko wersji 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.