Plugin Vertex AI

Plugin Vertex AI menyediakan antarmuka ke beberapa layanan AI:

Penginstalan

npm i --save @genkit-ai/vertexai

Jika ingin menjalankan flow yang menggunakan plugin ini secara lokal, Anda juga perlu menginstal alat Google Cloud CLI.

Konfigurasi

Untuk menggunakan plugin ini, tentukan saat Anda menginisialisasi Genkit:

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

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

Plugin ini mengharuskan Anda menentukan project ID Google Cloud, region tempat Anda ingin membuat permintaan Vertex API, dan kredensial project Google Cloud Anda.

  • Anda dapat menentukan project ID Google Cloud dengan menetapkan projectId dalam konfigurasi vertexAI() atau dengan menetapkan variabel lingkungan GCLOUD_PROJECT. Jika Anda menjalankan flow dari lingkungan Google Cloud (Cloud Functions, Cloud Run, dan sebagainya), GCLOUD_PROJECT akan otomatis ditetapkan ke project ID lingkungan.
  • Anda dapat menentukan lokasi API dengan menetapkan location dalam konfigurasi vertexAI() atau dengan menetapkan variabel lingkungan GCLOUD_LOCATION.

  • Untuk memberikan kredensial API, Anda perlu menyiapkan Kredensial Default Aplikasi Google Cloud.

    1. Untuk menentukan kredensial Anda:

      • Jika Anda menjalankan flow dari lingkungan Google Cloud (Cloud Functions, Cloud Run, dan sebagainya), kredensial tersebut ditetapkan secara otomatis.

      • Di lingkungan pengembangan lokal Anda, lakukan hal ini dengan menjalankan:

        gcloud auth application-default login

      • Untuk lingkungan lainnya, lihat dokumen Kredensial Default Aplikasi.

    2. Selain itu, pastikan akun diberi peran IAM Vertex AI User (roles/aiplatform.user). Lihat dokumen kontrol akses Vertex AI.

Penggunaan

Model AI Generatif

Plugin ini mengekspor referensi secara statis ke model AI generatif yang didukungnya:

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

Anda dapat menggunakan referensi ini untuk menentukan model yang digunakan 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?',
});

Plugin ini juga mendukung respons teks Gemini yang dihubungkan menggunakan Google Penelusuran atau data Anda sendiri.

Contoh:

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

Plugin ini juga mengekspor referensi secara statis ke model penyematan teks Gecko:

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

Anda dapat menggunakan referensi ini untuk menentukan penyempan yang digunakan pengindeksan atau pengambil. Misalnya, jika Anda menggunakan Chroma DB:

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

Atau, Anda dapat membuat penyematan secara langsung:

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 memungkinkan pembuatan gambar dari perintah pengguna:

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

dan bahkan pengeditan lanjutan pada gambar yang ada:

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

Lihat dokumentasi model Imagen untuk mengetahui opsi yang lebih mendetail.

Claude 3 dari Anthropic di Model Garden Vertex AI

Jika memiliki akses ke model Claude 3 (haiku, soneta, atau opus) di Vertex AI Model Garden, Anda dapat menggunakannya dengan Genkit.

Berikut adalah contoh konfigurasi untuk mengaktifkan model Vertex AI Model Garden:

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

Kemudian, gunakan sebagai model reguler:

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

Llama 3.1 405b di Model Garden Vertex AI

Pertama, Anda harus mengaktifkan Layanan API Llama 3.1 di Vertex AI Model Garden.

Berikut adalah contoh konfigurasi untuk Llama 3.1 405b di plugin Vertex AI:

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

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

Kemudian, gunakan sebagai model reguler:

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

Model Mistral di Model Garden Vertex AI

Jika memiliki akses ke model Mistral (Mistral Large, Mistral Nemo, atau Codestral) di Model Garden Vertex AI, Anda dapat menggunakannya dengan Genkit.

Berikut adalah contoh konfigurasi untuk mengaktifkan model Vertex AI Model Garden:

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

Kemudian, gunakan sebagai model reguler:

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

Model ini mendukung: - mistralLarge: Model besar Mistral terbaru dengan kemampuan panggilan fungsi - mistralNemo: Dioptimalkan untuk efisiensi dan kecepatan - codestral: Dikhususkan untuk tugas pembuatan kode

Setiap model mendukung respons streaming dan panggilan fungsi:

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

Evaluator

Untuk menggunakan evaluator dari Vertex AI Rapid Evaluation, tambahkan blok evaluation ke konfigurasi plugin vertexAI Anda.

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

Konfigurasi di atas menambahkan evaluator untuk metrik Safety dan ROUGE. Contoh ini menunjukkan dua pendekatan- metrik Safety menggunakan spesifikasi default, sedangkan metrik ROUGE memberikan spesifikasi yang disesuaikan yang menetapkan jenis rouge ke rougeLsum.

Kedua evaluator dapat dijalankan menggunakan perintah genkit eval:run dengan set data yang kompatibel: yaitu, set data dengan kolom output dan reference. Evaluator Safety juga dapat dijalankan menggunakan perintah genkit eval:flow -e vertexai/safety karena hanya memerlukan output.

Indexer dan retriever

Plugin Genkit Vertex AI menyertakan implementasi pengindeksan dan pengambilan yang didukung oleh layanan Vertex AI Vector Search.

(Lihat halaman Retrieval-augmented generation untuk mempelajari cara indexer dan retriever digunakan dalam implementasi RAG.)

Layanan Vertex AI Vector Search adalah indeks dokumen yang berfungsi bersama penyimpanan dokumen pilihan Anda: penyimpanan dokumen berisi konten dokumen, dan indeks Vertex AI Vector Search berisi, untuk setiap dokumen, penyematan vektornya dan referensi ke dokumen di penyimpanan dokumen. Setelah dokumen Anda diindeks oleh layanan Vertex AI Vector Search, layanan ini dapat merespons kueri penelusuran, yang menghasilkan daftar indeks ke dalam penyimpanan dokumen Anda.

Implementasi pengindeksan dan pengambilan yang disediakan oleh plugin Vertex AI menggunakan Cloud Firestore atau BigQuery sebagai penyimpanan dokumen. Plugin ini juga menyertakan antarmuka yang dapat Anda terapkan untuk mendukung penyimpanan dokumen lainnya.

Untuk menggunakan Vertex AI Vector Search:

  1. Pilih model penyematan. Model ini bertanggung jawab untuk membuat embedding vektor dari teks. Pengguna tingkat lanjut mungkin menggunakan model penyematan yang dioptimalkan untuk set data tertentu, tetapi bagi sebagian besar pengguna, model text-embedding-004 Vertex AI adalah pilihan yang baik untuk teks bahasa Inggris dan model text-multilingual-embedding-002 cocok untuk teks multibahasa.

  2. Di bagian Vector Search di konsol Google Cloud, buat indeks baru. Setelan yang paling penting adalah:

    • Dimensi: Tentukan dimensi vektor yang dihasilkan oleh model penyematan yang Anda pilih. Model text-embedding-004 dan text-multilingual-embedding-002 menghasilkan vektor 768 dimensi.
    • Metode update: Pilih update streaming.

    Setelah membuat indeks, deploy ke endpoint standar (publik).

  3. Dapatkan pengindeksan dan pengambil dokumen untuk penyimpanan dokumen yang ingin Anda gunakan:

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

    Lainnya

    Untuk mendukung penyimpanan dokumen lain, Anda dapat menyediakan implementasi DocumentRetriever dan DocumentIndexer Anda sendiri:

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

    Untuk contohnya, lihat Contoh Pengambil dan Pengindeksan Plugin Vertex AI dengan File Lokal.

  4. Tambahkan blok vectorSearchOptions ke konfigurasi plugin vertexAI Anda:

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

    Berikan penyempan yang Anda pilih di langkah pertama serta pengindeksan dan pengambil dokumen yang Anda buat di langkah sebelumnya.

    Untuk mengonfigurasi plugin agar menggunakan indeks Penelusuran Vektor yang Anda buat sebelumnya, Anda perlu memberikan beberapa nilai, yang dapat Anda temukan di bagian Penelusuran Vektor di konsol Google Cloud:

    • indexId: tercantum di tab Indeks
    • indexEndpointId: tercantum di tab Endpoint Indeks
    • deployedIndexId dan publicDomainName: tercantum di halaman "Info indeks yang di-deploy", yang dapat Anda buka dengan mengklik nama indeks yang di-deploy di salah satu tab yang disebutkan sebelumnya

  5. Setelah semuanya dikonfigurasi, Anda dapat menggunakan pengindeksan dan pengambil di aplikasi 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,
});

Lihat contoh kode untuk:

Penyimpanan Cache Konteks

Plugin Vertex AI Genkit mendukung Pemcachean Konteks, yang memungkinkan model menggunakan kembali konten yang di-cache sebelumnya untuk mengoptimalkan penggunaan token saat menangani konten dalam jumlah besar. Fitur ini sangat berguna untuk alur percakapan atau skenario saat model mereferensikan sebagian besar konten secara konsisten di beberapa permintaan.

Cara Menggunakan Cache Konteks

Untuk mengaktifkan cache konteks, pastikan model Anda mendukungnya. Misalnya, gemini15Flash dan gemini15Pro adalah model yang mendukung penyimpanan dalam cache konteks, dan Anda harus menentukan nomor versi 001.

Anda dapat menentukan mekanisme penyimpanan dalam aplikasi seperti ini:

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

Dalam penyiapan ini: - messages: Memungkinkan Anda meneruskan histori percakapan. - metadata.cache.ttlSeconds: Menentukan time-to-live (TTL) untuk meng-cache respons tertentu.

Contoh: Memanfaatkan Teks Besar dengan Konteks

Untuk aplikasi yang mereferensikan dokumen panjang, seperti War and Peace atau Lord of the Rings, Anda dapat menyusun kueri untuk menggunakan kembali konteks yang di-cache:


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

Manfaat Cache Konteks

  1. Peningkatan Performa: Mengurangi kebutuhan untuk pemrosesan berulang input besar.
  2. Efisiensi Biaya: Mengurangi penggunaan API untuk data yang redundan, sehingga mengoptimalkan konsumsi token.
  3. Latensi yang Lebih Baik: Mempercepat waktu respons untuk kueri berulang atau terkait.

Model yang Didukung untuk Penyimpanan dalam Cache Konteks

Hanya model tertentu, seperti gemini15Flash dan gemini15Pro, yang mendukung penyimpanan dalam cache konteks, dan saat ini hanya pada nomor versi 001. Jika model yang tidak didukung digunakan, error akan muncul, yang menunjukkan bahwa penyimpanan dalam cache tidak dapat diterapkan.

Bacaan Lebih Lanjut

Lihat informasi selengkapnya tentang penyimpanan dalam cache konteks di Vertex AI dalam dokumentasinya.