Mendaftarkan dan memanggil model AI jarak jauh menggunakan pengelolaan endpoint model

Halaman ini menjelaskan cara memanggil prediksi atau membuat penyematan menggunakan model, dengan mendaftarkan endpoint model ke pengelolaan endpoint model.

Sebelum memulai

Menyiapkan ekstensi

  1. Hubungkan ke database Anda menggunakan psql atau AlloyDB for PostgreSQL Studio menggunakan pengguna postgres.

  2. Opsional: Minta akses untuk berinteraksi dengan fitur mesin kueri AI AlloyDB untuk PostgreSQL (Pratinjau) termasuk dukungan untuk model multimodal, model peringkat, dan fungsi operator.

  3. Opsional: Berikan izin kepada pengguna PostgreSQL non-super untuk mengelola metadata model:

      GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA google_ml TO NON_SUPER_USER;

    Ganti variabel berikut:

    • NON_SUPER_USER: nama pengguna PostgreSQL non-super.

  4. Pastikan IP keluar diaktifkan untuk mengakses model yang dihosting di luar VPC Anda, seperti model pihak ketiga. Untuk mengetahui informasi selengkapnya, lihat Menambahkan konektivitas keluar.

Menyiapkan autentikasi

Bagian berikut menunjukkan cara menyiapkan autentikasi sebelum mendaftarkan endpoint model.

Menyiapkan autentikasi untuk Vertex AI

Untuk menggunakan endpoint model Google Vertex AI, Anda harus menambahkan izin Vertex AI ke akun layanan AlloyDB berbasis IAM yang Anda gunakan untuk terhubung ke database. Untuk informasi selengkapnya tentang cara berintegrasi dengan Vertex AI, lihat Berintegrasi dengan Vertex AI.

Menyiapkan autentikasi menggunakan Secret Manager

Bagian ini menjelaskan cara menyiapkan autentikasi jika Anda menggunakan Secret Manager untuk menyimpan detail autentikasi bagi penyedia pihak ketiga.

Langkah ini bersifat opsional jika endpoint model Anda tidak menangani autentikasi melalui Secret Manager—misalnya, jika endpoint model Anda menggunakan header HTTP untuk meneruskan informasi autentikasi atau tidak menggunakan autentikasi sama sekali.

Untuk membuat dan menggunakan kunci API atau token pembawa, selesaikan langkah-langkah berikut:

  1. Buat secret di Secret Manager. Untuk mengetahui informasi selengkapnya, lihat Membuat secret dan mengakses versi secret.

    Jalur secret digunakan dalam fungsi SQL google_ml.create_sm_secret().

  2. Berikan izin ke cluster AlloyDB untuk mengakses secret.

      gcloud secrets add-iam-policy-binding 'SECRET_NAME' \
      --member="serviceAccount:SERVICE_ACCOUNT_ID" \
      --role="roles/secretmanager.secretAccessor"

    Ganti kode berikut:

    • SECRET_NAME: nama secret di Secret Manager.

    • SERVICE_ACCOUNT_ID: ID akun layanan berbasis IAM dalam format serviceAccount:service-PROJECT_ID@gcp-sa-alloydb.—misalnya, service-212340152456@gcp-sa-alloydb..

      Anda juga dapat memberikan peran ini ke akun layanan di tingkat project. Untuk mengetahui informasi selengkapnya, lihat Menambahkan pengikatan kebijakan Identity and Access Management

Menyiapkan autentikasi menggunakan header

Contoh berikut menunjukkan cara menyiapkan autentikasi menggunakan fungsi. Fungsi menampilkan objek JSON yang berisi header yang diperlukan untuk membuat permintaan ke model embedding.

  CREATE OR REPLACE FUNCTION HEADER_GEN_FUNCTION(
    model_id VARCHAR(100),
    input_text TEXT
  )
  RETURNS JSON
  LANGUAGE plpgsql
  AS $$
  #variable_conflict use_variable
  DECLARE
    api_key VARCHAR(255) := 'API_KEY';
    header_json JSON;
  BEGIN
    header_json := json_build_object(
      'Content-Type', 'application/json',
      'Authorization', 'Bearer ' || api_key
    );
    RETURN header_json;
  END;
  $$;

Ganti kode berikut:

  • HEADER_GEN_FUNCTION: nama fungsi pembuatan header yang dapat Anda gunakan saat mendaftarkan model.
  • API_KEY: kunci API penyedia model.

Model embedding teks

Bagian ini menunjukkan cara mendaftarkan endpoint model dengan pengelolaan endpoint model.

Pengelolaan endpoint model mendukung beberapa model penyematan teks dan Vertex AI generik sebagai endpoint model yang telah didaftarkan sebelumnya. Anda dapat langsung menggunakan ID model untuk membuat embedding atau memanggil prediksi, berdasarkan jenis model. Untuk mengetahui informasi selengkapnya tentang model pra-terdaftar yang didukung, lihat Model Vertex AI pra-terdaftar.

Model gemini-embedding-001 hanya tersedia di wilayah us-central1.

Misalnya, untuk memanggil model gemini-embedding-001 yang telah terdaftar sebelumnya, Anda dapat langsung memanggil model menggunakan fungsi embedding:

SELECT
      embedding(
        model_id => 'gemini-embedding-001',
        content => 'AlloyDB is a managed, cloud-hosted SQL database service');

Jika cluster AlloyDB dan endpoint Vertex AI Anda berada di project yang berbeda, tetapkan model_id ke jalur endpoint yang memenuhi syarat—misalnya, projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/gemini-embedding-001.

Demikian pula, untuk memanggil model gemini-1.5-pro:generateContent yang telah didaftarkan sebelumnya, Anda dapat langsung memanggil model menggunakan fungsi prediksi:

 SELECT google_ml.predict_row(
            model_id => 'gemini-1.5-pro:generateContent',
            request_body => '{
        "contents": [
            {
                "role": "user",
                "parts": [
                    {
                        "text": "For TPCH database schema as mentioned here https://www.tpc.org/TPC_Documents_Current_Versions/pdf/TPC-H_v3.0.1.pdf , generate a SQL query to find all supplier names which are located in the India nation. Only provide SQL query with no explanation."
                    }
                ]
            }
        ]
        }')-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text';

Untuk membuat embedding, lihat cara membuat embedding teks. Untuk memanggil prediksi, lihat cara memanggil prediksi.

Model embedding teks dengan dukungan bawaan

Pengelolaan endpoint model menyediakan dukungan bawaan untuk beberapa model dari Vertex AI dan OpenAI. Untuk mengetahui daftar model dengan dukungan bawaan, lihat Model dengan dukungan bawaan.

Untuk model dengan dukungan bawaan, Anda dapat menetapkan nama yang memenuhi syarat sebagai nama yang memenuhi syarat model dan menentukan URL permintaan. Pengelolaan endpoint model secara otomatis mengidentifikasi model dan menyiapkan fungsi transformasi default.

Model penyematan Vertex AI

Langkah-langkah berikut menunjukkan cara mendaftarkan model Vertex AI dengan dukungan bawaan. Endpoint model gemini-embedding-001 dan text-multilingual-embedding-002 digunakan sebagai contoh.

Pastikan cluster AlloyDB dan model Vertex AI yang Anda kueri berada di region yang sama.

  1. Hubungkan ke database Anda menggunakan psql.

  2. Siapkan ekstensi google_ml_integration.

  3. Panggil fungsi pembuatan model untuk menambahkan endpoint model:

    gemini-embedding-001 

      CALL
    google_ml.create_model(
      model_id => 'gemini-embedding-001',
      model_request_url => 'publishers/google/models/gemini-embedding-001',
      model_provider => 'google',
      model_qualified_name => 'gemini-embedding-001',
      model_type => 'text_embedding',
      model_auth_type => 'alloydb_service_agent_iam');

    text-multilingual-embedding-002 

      CALL
    google_ml.create_model(
      model_id => 'text-multilingual-embedding-002',
      model_request_url => 'publishers/google/models/text-multilingual-embedding-002',
      model_provider => 'google',
      model_qualified_name => 'text-multilingual-embedding-002',
      model_type => 'text_embedding',
      model_auth_type => 'alloydb_service_agent_iam'
      model_in_transform_fn => 'google_ml.vertexai_text_embedding_input_transform',
      model_out_transform_fn => 'google_ml.vertexai_text_embedding_output_transform');

Jika model disimpan di project dan region lain selain cluster AlloyDB Anda, tetapkan URL permintaan ke projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/MODEL_ID, dengan REGION_ID adalah region tempat model Anda dihosting, dan MODEL_ID adalah nama model yang memenuhi syarat.

Selain itu, berikan peran Vertex AI User (roles/aiplatform.user) ke akun layanan AlloyDB dari project tempat instance AlloyDB berada agar AlloyDB dapat mengakses model yang dihosting di project lain.

Model embedding teks AI terbuka

Ekstensi google_ml_integration secara otomatis menyiapkan fungsi transformasi default dan memanggil model OpenAI jarak jauh. Untuk mengetahui daftar model OpenAI dengan dukungan bawaan, lihat Model dengan dukungan bawaan.

Contoh berikut menambahkan endpoint model OpenAI text-embedding-ada-002. Anda dapat mendaftarkan endpoint model text-embedding-3-small dan text-embedding-3-large OpenAI menggunakan langkah-langkah yang sama dan menetapkan nama lengkap model yang khusus untuk model tersebut.

  1. Hubungkan ke database Anda menggunakan psql.
  2. Siapkan ekstensi google_ml_integration.
  3. Tambahkan kunci API OpenAI sebagai rahasia ke Secret Manager untuk autentikasi.

  4. Panggil secret yang disimpan di Secret Manager:

    CALL
google_ml.create_sm_secret(
  secret_id => 'SECRET_ID',
  secret_path => 'projects/PROJECT_ID/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

    Ganti kode berikut:

    • SECRET_ID: ID rahasia yang Anda tetapkan dan selanjutnya digunakan saat mendaftarkan endpoint model—misalnya, key1.
    • SECRET_MANAGER_SECRET_ID: ID secret yang ditetapkan di Secret Manager saat Anda membuat secret.
    • PROJECT_ID: ID Google Cloud project Anda.
    • VERSION_NUMBER: nomor versi ID secret.

  5. Panggil fungsi pembuatan model untuk mendaftarkan endpoint model text-embedding-ada-002:

    CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'open_ai',
    model_type => 'text_embedding',
    model_qualified_name => 'text-embedding-ada-002',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID');

    Ganti kode berikut:

    • MODEL_ID: ID unik untuk endpoint model yang Anda tentukan. ID model ini dirujuk untuk metadata yang diperlukan endpoint model guna membuat embedding atau memanggil prediksi.
    • SECRET_ID: ID secret yang Anda gunakan sebelumnya dalam prosedur google_ml.create_sm_secret().

Untuk membuat embedding, lihat membuat embedding teks.

Model embedding teks yang dihosting kustom

Bagian ini menunjukkan cara mendaftarkan endpoint model yang dihosting kustom beserta pembuatan fungsi transformasi, dan secara opsional, header HTTP kustom. Semua endpoint model yang dihosting kustom didukung, terlepas dari tempat dihostingnya.

Contoh berikut menambahkan endpoint model kustom custom-embedding-model yang dihosting oleh Cymbal. Fungsi transformasi cymbal_text_input_transform dan cymbal_text_output_transform digunakan untuk mengubah format input dan output model menjadi format input dan output fungsi prediksi.

Untuk mendaftarkan endpoint model penyematan teks yang dihosting kustom, selesaikan langkah-langkah berikut:

  1. Hubungkan ke database Anda menggunakan psql.

  2. Siapkan ekstensi google_ml_integration.

  3. Opsional: Tambahkan kunci API sebagai secret ke Secret Manager untuk autentikasi.

  4. Panggil secret yang disimpan di Secret Manager:

    CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/project-id/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

    Ganti kode berikut:

    • SECRET_ID: ID rahasia yang Anda tetapkan dan selanjutnya digunakan saat mendaftarkan endpoint model—misalnya, key1.
    • SECRET_MANAGER_SECRET_ID: ID secret yang ditetapkan di Secret Manager saat Anda membuat secret.
    • PROJECT_ID: ID Google Cloud project Anda.
    • VERSION_NUMBER: nomor versi ID secret.

  5. Buat fungsi transformasi input dan output berdasarkan tanda tangan berikut untuk fungsi prediksi untuk endpoint model penyematan teks. Untuk mengetahui informasi selengkapnya tentang cara membuat fungsi transformasi, lihat Contoh fungsi transformasi.

    Berikut adalah contoh fungsi transformasi yang khusus untuk endpoint model penyematan teks custom-embedding-model:

    -- Input Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION cymbal_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_input JSON;
  model_qualified_name TEXT;
BEGIN
  SELECT json_build_object('prompt', json_build_array(input_text))::JSON INTO transformed_input;
  RETURN transformed_input;
END;
$$;
-- Output Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION cymbal_text_output_transform(model_id VARCHAR(100), response_json JSON)
RETURNS REAL[]
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_output REAL[];
BEGIN
  SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output;
  RETURN transformed_output;
END;
$$;

  6. Panggil fungsi pembuatan model untuk mendaftarkan endpoint model embedding kustom:

    CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_request_url => 'REQUEST_URL',
    model_provider => 'custom',
    model_type => 'text_embedding',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID',
    model_qualified_name => 'MODEL_QUALIFIED_NAME',
    model_in_transform_fn => 'cymbal_text_input_transform',
    model_out_transform_fn => 'cymbal_text_output_transform');

    Ganti kode berikut:

    • MODEL_ID: wajib diisi. ID unik untuk endpoint model yang Anda tentukan, misalnya custom-embedding-model. ID model ini dirujuk untuk metadata yang diperlukan endpoint model guna membuat embedding atau memanggil prediksi.
    • REQUEST_URL: wajib diisi. Endpoint khusus model saat menambahkan penyematan teks kustom dan endpoint model generik—misalnya, https://cymbal.com/models/text/embeddings/v1. Pastikan endpoint model dapat diakses melalui alamat IP internal. Pengelolaan endpoint model tidak mendukung alamat IP publik.
    • MODEL_QUALIFIED_NAME: wajib diisi jika endpoint model Anda menggunakan nama yang memenuhi syarat. Nama yang sepenuhnya memenuhi syarat jika endpoint model memiliki beberapa versi.
    • SECRET_ID: ID secret yang Anda gunakan sebelumnya dalam prosedur google_ml.create_sm_secret().

Model multimodal dengan dukungan bawaan

Berintegrasi dengan Vertex AI dan menginstal ekstensi

  1. Berintegrasi dengan Vertex AI.
  2. Pastikan google_ml_integration versi terbaru sudah diinstal.

    1. Untuk memeriksa versi yang diinstal, jalankan perintah berikut:

              SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
        extversion
        ------------
        1.4.3
        (1 row)

    2. Jika ekstensi tidak diinstal atau jika versi yang diinstal lebih lama dari 1.4.3, update ekstensi dengan menjalankan perintah berikut:

              CREATE EXTENSION IF NOT EXISTS google_ml_integration;
        ALTER EXTENSION google_ml_integration UPDATE;

      Jika Anda mengalami masalah saat menjalankan perintah sebelumnya, atau jika ekstensi tidak diupdate ke versi 1.4.3 setelah Anda menjalankan perintah sebelumnya, hubungi dukungan AlloyDB.

    3. Setelah Anda memastikan bahwa versi sudah yang terbaru, instal fungsi pratinjau dengan menjalankan prosedur upgrade_to_preview_version:

              CALL google_ml.upgrade_to_preview_version();
        SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
        extversion
        ------------
        1.4.4
        (1 row)

Memanggil model untuk menghasilkan embedding multimodal

Karena pengelolaan endpoint Model menyediakan dukungan bawaan untuk model multimodalembedding@001 oleh Vertex AI, Anda dapat langsung memanggil model untuk membuat embedding multimodal.

Contoh berikut menggunakan nama model yang memenuhi syarat multimodalembedding@001 sebagai ID model untuk membuat embedding gambar multimodal:

  1. Hubungkan ke database Anda menggunakan psql.
  2. Siapkan ekstensi google_ml_integration.

  3. Membuat embedding gambar multimodal:

    SELECT
  ai.image_embedding(
    model_id => 'multimodalembedding@001',
    image => 'IMAGE_PATH_OR_TEXT',
    mimetype => 'MIMETYPE');

Ganti kode berikut:

  • IMAGE_PATH_OR_TEXT dengan jalur Cloud Storage ke gambar, misalnya-gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg untuk diterjemahkan ke dalam vektor embedding atau string base64 gambar.
  • MIMETYPE dengan mimetype gambar.

Model peringkat

Model ranking Vertex AI

Anda dapat menggunakan model Vertex AI yang disebutkan dalam Model yang didukung tanpa pendaftaran.

Untuk mempelajari cara memberi peringkat hasil penelusuran menggunakan model peringkat Vertex AI, lihat Beri peringkat hasil penelusuran.

Mendaftarkan model peringkat pihak ketiga

Contoh berikut menunjukkan cara mendaftarkan model peringkat ulang dari Cohere.

CREATE OR REPLACE FUNCTION cohere_rerank_input_transform(
    model_id VARCHAR(100),
    search_string TEXT,
    documents TEXT[],
    top_n INT DEFAULT NULL
)
RETURNS JSON
LANGUAGE plpgsql
AS $$
#variable_conflict use_variable
DECLARE
  transformed_input JSONB;
BEGIN
  -- Basic Input Validation
  IF search_string IS NULL OR search_string = '' THEN
    RAISE EXCEPTION 'Invalid input: search_string cannot be NULL or empty.';
  END IF;

  IF documents IS NULL OR array_length(documents, 1) IS NULL OR array_length(documents, 1) = 0 THEN
    RAISE EXCEPTION 'Invalid input: documents array cannot be NULL or empty.';
  END IF;

  IF top_n IS NOT NULL AND top_n < 0 THEN
    RAISE EXCEPTION 'Invalid input: top_n must be greater than or equal to zero. Provided value: %', top_n;
  END IF;

  -- Construct the base JSON payload for Cohere Rerank API
  transformed_input := jsonb_build_object(
    'model', google_ml.model_qualified_name_of(model_id),
    'query', search_string,
    'documents', to_jsonb(documents), -- Convert TEXT[] directly to JSON array
    'return_documents', false -- Explicitly set to false (optional, as its default)
  );

  -- Add top_n to the payload only if it's provided and valid
  IF top_n IS NOT NULL THEN
     transformed_input := transformed_input || jsonb_build_object('top_n', top_n);
  END IF;

  -- Return the final JSON payload
  RETURN transformed_input::JSON;

END;
$$;

CREATE OR REPLACE FUNCTION cohere_rerank_output_transform(
    model_id VARCHAR(100),
    response_json JSON
)
RETURNS TABLE (index INT, score REAL)
LANGUAGE plpgsql
AS $$
DECLARE
  result_item JSONB;
  response_jsonb JSONB;
  cohere_index INT; -- 0-based index from Cohere response
BEGIN
  -- Validate response_json
  IF response_json IS NULL THEN
    RAISE EXCEPTION 'Invalid model response: response cannot be NULL.';
  END IF;

  -- Convert JSON to JSONB for easier processing
  response_jsonb := response_json::JSONB;

  -- Check top-level structure
  IF jsonb_typeof(response_jsonb) != 'object' THEN
    RAISE EXCEPTION 'Invalid model response: response must be a JSON object. Found: %', jsonb_typeof(response_jsonb);
  END IF;

  -- Check for the 'results' array
  IF response_jsonb->'results' IS NULL OR jsonb_typeof(response_jsonb->'results') != 'array' THEN
    -- Check for potential Cohere error structure
    IF response_jsonb->'message' IS NOT NULL THEN
       RAISE EXCEPTION 'Cohere API Error: %', response_jsonb->>'message';
    ELSE
       RAISE EXCEPTION 'Invalid model response: response does not contain a valid "results" array.';
    END IF;
  END IF;

  -- Loop through the 'results' array (JSONB array indices are 0-based)
  FOR i IN 0..jsonb_array_length(response_jsonb->'results') - 1 LOOP
    result_item := response_jsonb->'results'->i;

    -- Validate individual result item structure
    IF result_item IS NULL OR jsonb_typeof(result_item) != 'object' THEN
      RAISE WARNING 'Skipping invalid result item at array index %.', i;
      CONTINUE;
    END IF;

    IF result_item->'index' IS NULL OR jsonb_typeof(result_item->'index') != 'number' THEN
       RAISE WARNING 'Missing or invalid "index" field in result item at array index %.', i;
       CONTINUE;
    END IF;

    IF result_item->'relevance_score' IS NULL OR jsonb_typeof(result_item->'relevance_score') != 'number' THEN
       RAISE WARNING 'Missing or invalid "relevance_score" field in result item at array index %.', i;
       CONTINUE;
    END IF;

    -- Extract values
    BEGIN
      cohere_index := (result_item->>'index')::INT;
      -- Assign values to the output table columns
      -- Cohere returns 0-based index, map it to 1-based for consistency
      -- with input document array position
      index := cohere_index + 1;
      score := (result_item->>'relevance_score')::REAL;
      RETURN NEXT; -- Return the current row
    EXCEPTION WHEN others THEN
      RAISE WARNING 'Error processing result item at array index %: %', i, SQLERRM;
      CONTINUE; -- Skip this item and continue with the next
    END;
  END LOOP;

  RETURN; -- End of function
END;
$$;

CALL
  google_ml.create_sm_secret(
    '<SECRET_ID>',
    'projects/<PROJECT_NUMBER>/secrets/<SECRET_ID>/versions/latest');

CALL
  google_ml.create_model(
    model_id => 'cohere-reranker',
    model_type => 'reranking',
    model_provider => 'custom',
    model_request_url => 'https://api.cohere.com/v2/rerank',
    model_qualified_name => 'rerank-v3.5',
    model_auth_type => 'secret_manager',
    model_auth_id => '<SECRET_ID>',
    model_in_transform_fn => 'cohere_rerank_input_transform',
    model_out_transform_fn => 'cohere_rerank_output_transform'
  );

Model generik

Bagian ini menunjukkan cara mendaftarkan endpoint model generik apa pun yang tersedia di penyedia model yang dihosting seperti Hugging Face, OpenAI, Vertex AI, Anthropic, atau penyedia lainnya. Bagian ini menunjukkan contoh untuk mendaftarkan endpoint model generik yang dihosting di Hugging Face, model gemini-pro generik dari Vertex AI Model Garden, dan endpoint model claude-haiku.

Anda dapat mendaftarkan endpoint model generik apa pun selama input dan outputnya dalam format JSON. Berdasarkan metadata endpoint model, Anda mungkin perlu membuat header HTTP atau menentukan URL permintaan.

Untuk mengetahui informasi selengkapnya tentang model generik yang telah didaftarkan sebelumnya dan model dengan dukungan bawaan, lihat Model yang didukung.

Model Gemini generik

Bagian ini menunjukkan cara mendaftarkan model Gemini generik.

Model gemini-1.5-pro

Karena beberapa model gemini-pro telah didaftarkan sebelumnya, Anda dapat langsung memanggil ID model untuk memanggil prediksi.

Contoh berikut menggunakan endpoint model gemini-1.5-pro:generateContent dari Vertex AI Model Garden.

  1. Hubungkan ke database Anda menggunakan psql.
  2. Siapkan ekstensi google_ml_integration.

  3. Panggil prediksi menggunakan ID model yang telah didaftarkan sebelumnya:

    SELECT
    json_array_elements(
    google_ml.predict_row(
        model_id => 'gemini-1.5-pro:generateContent',
        request_body => '{
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "For TPCH database schema as mentioned here https://www.tpc.org/TPC_Documents_Current_Versions/pdf/TPC-H_v3.0.1.pdf , generate a SQL query to find all supplier names which are located in the India nation."
                }
            ]
        }
    ]
    }'))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text';

Model generik di Hugging Face

Contoh berikut menambahkan endpoint model klasifikasi kustom facebook/bart-large-mnli yang dihosting di Hugging Face.

  1. Hubungkan ke database Anda menggunakan psql.
  2. Siapkan ekstensi google_ml_integration.
  3. Tambahkan kunci API OpenAI sebagai rahasia ke Secret Manager untuk autentikasi. Jika Anda telah membuat secret untuk model OpenAI lainnya, Anda dapat menggunakan kembali secret yang sama.

  4. Panggil secret yang disimpan di Secret Manager:

    CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/project-id/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

    Ganti kode berikut:

    • SECRET_ID: ID rahasia yang Anda tetapkan dan selanjutnya digunakan saat mendaftarkan endpoint model.
    • SECRET_MANAGER_SECRET_ID: ID secret yang ditetapkan di Secret Manager saat Anda membuat secret.
    • PROJECT_ID: ID Google Cloud project Anda.
    • VERSION_NUMBER: nomor versi ID secret.

  5. Panggil fungsi pembuatan model untuk mendaftarkan endpoint model facebook/bart-large-mnli:

    CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'hugging_face',
    model_request_url => 'REQUEST_URL',
    model_qualified_name => 'MODEL_QUALIFIED_NAME',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID');

    Ganti kode berikut:

    • MODEL_ID: ID unik untuk endpoint model yang Anda tentukan—misalnya, custom-classification-model. ID model ini dirujuk untuk metadata yang diperlukan endpoint model guna membuat embedding atau memanggil prediksi.
    • REQUEST_URL: endpoint khusus model saat menambahkan embedding teks kustom dan endpoint model generik—misalnya, https://api-inference.huggingface.co/models/facebook/bart-large-mnli.
    • MODEL_QUALIFIED_NAME: nama versi endpoint model yang sepenuhnya memenuhi syarat—misalnya, facebook/bart-large-mnli.
    • SECRET_ID: ID secret yang Anda gunakan sebelumnya dalam prosedur google_ml.create_sm_secret().

Model generik Anthropic

Contoh berikut menambahkan endpoint model claude-3-opus-20240229. Pengelolaan endpoint model menyediakan fungsi header yang diperlukan untuk mendaftarkan model Anthropic.

  1. Hubungkan ke database Anda menggunakan psql.

  2. Buat dan aktifkan ekstensi google_ml_integration.

    Secret Manager

    1. Tambahkan token pembawa sebagai secret ke Secret Manager untuk autentikasi.

    2. Panggil secret yang disimpan di Secret Manager:

      CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/PROJECT_ID/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

      Ganti kode berikut:

      • SECRET_ID: ID rahasia yang Anda tetapkan dan selanjutnya digunakan saat mendaftarkan endpoint model.
      • SECRET_MANAGER_SECRET_ID: ID secret yang ditetapkan di Secret Manager saat Anda membuat secret.
      • PROJECT_ID: ID Google Cloud project Anda.
      • VERSION_NUMBER: nomor versi ID secret.

    3. Panggil fungsi pembuatan model untuk mendaftarkan endpoint model claude-3-opus-20240229.

      CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'anthropic',
    model_request_url => 'REQUEST_URL',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID',
    generate_headers_fn => 'google_ml.anthropic_claude_header_gen_fn');

      Ganti kode berikut:

      • MODEL_ID: ID unik untuk endpoint model yang Anda tentukan—misalnya, anthropic-opus. ID model ini dirujuk untuk metadata yang diperlukan endpoint model guna membuat embedding atau memanggil prediksi.
      • REQUEST_URL: endpoint khusus model saat menambahkan embedding teks kustom dan endpoint model generik—misalnya, https://api.anthropic.com/v1/messages.

    Header Auth

    1. Gunakan fungsi pembuatan header default google_ml.anthropic_claude_header_gen_fn atau buat fungsi pembuatan header.

        CREATE OR REPLACE FUNCTION anthropic_sample_header_gen_fn(model_id VARCHAR(100), request_body JSON)
  RETURNS JSON
  LANGUAGE plpgsql
  AS $$
  #variable_conflict use_variable
  BEGIN
        RETURN json_build_object('x-api-key', 'ANTHROPIC_API_KEY', 'anthropic-version', 'ANTHROPIC_VERSION')::JSON;
  END;
  $$;

      Ganti kode berikut:

      • ANTHROPIC_API_KEY: kunci API anthropic.
      • ANTHROPIC_VERSION (Opsional): versi model tertentu yang ingin Anda gunakan—misalnya, 2023-06-01.

    2. Panggil fungsi pembuatan model untuk mendaftarkan endpoint model claude-3-opus-20240229.

      CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'anthropic',
    model_request_url => 'REQUEST_URL',
    generate_headers_fn => 'google_ml.anthropic_claude_header_gen_fn');

      Ganti kode berikut:

      • MODEL_ID: ID unik untuk endpoint model yang Anda tentukan—misalnya, anthropic-opus. ID model ini dirujuk untuk metadata yang diperlukan endpoint model guna membuat embedding atau memanggil prediksi.
      • REQUEST_URL: endpoint khusus model saat menambahkan embedding teks kustom dan endpoint model generik—misalnya, https://api.anthropic.com/v1/messages.

Untuk mengetahui informasi selengkapnya, lihat cara meminta prediksi untuk endpoint model generik.

Langkah berikutnya