Registe e chame modelos de IA remotos através da gestão de pontos finais de modelos

Esta página descreve como invocar previsões ou gerar incorporações através de um modelo, registando o ponto final do modelo com a gestão de pontos finais de modelos.

Antes de começar

Configure a extensão

  1. Estabeleça ligação à sua base de dados através do psql ou do AlloyDB para PostgreSQL Studio com o utilizador postgres.

  2. Opcional: Peça acesso para interagir com as funcionalidades do motor de consultas de IA do AlloyDB for PostgreSQL (pré-visualização), incluindo suporte para modelos multimodais, modelos de classificação e funções de operador.

  3. Opcional: conceda autorização a um utilizador do PostgreSQL sem privilégios de superadministrador para gerir os metadados do modelo:

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

    Substitua a seguinte variável:

    • NON_SUPER_USER: o nome de utilizador do PostgreSQL que não é superutilizador.

  4. Certifique-se de que o IP de saída está ativado para aceder a modelos alojados fora da sua VPC, como modelos de terceiros. Para mais informações, consulte o artigo Adicione conetividade de saída.

Configure a autenticação

As secções seguintes mostram como configurar a autenticação antes de registar um ponto final do modelo.

Configure a autenticação para o Vertex AI

Para usar os pontos finais do modelo do Google Vertex AI, tem de adicionar autorizações do Vertex AI à conta de serviço do AlloyDB baseada no IAM que usa para se ligar à base de dados. Para mais informações sobre a integração com o Vertex AI, consulte o artigo Integre com o Vertex AI.

Configure a autenticação através do Secret Manager

Esta secção explica como configurar a autenticação se estiver a usar o Secret Manager para armazenar detalhes de autenticação para fornecedores de terceiros.

Este passo é opcional se o seu ponto final do modelo não processar a autenticação através do Secret Manager, por exemplo, se o seu ponto final do modelo usar cabeçalhos HTTP para transmitir informações de autenticação ou não usar autenticação.

Para criar e usar uma chave da API ou um token de autorização, conclua os seguintes passos:

  1. Crie o Secret no Secret Manager. Para mais informações, consulte o artigo Crie um segredo e aceda a uma versão secreta.

    O caminho secreto é usado na função SQL google_ml.create_sm_secret().

  2. Conceda autorizações ao cluster do AlloyDB para aceder ao segredo.

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

    Substitua o seguinte:

    • SECRET_NAME: o nome do segredo no Secret Manager.

    • SERVICE_ACCOUNT_ID: o ID da conta de serviço baseada em IAM no formato serviceAccount:service-PROJECT_ID@gcp-sa-alloydb.iam.gserviceaccount.com, por exemplo, service-212340152456@gcp-sa-alloydb.iam.gserviceaccount.com.

      Também pode conceder esta função à conta de serviço ao nível do projeto. Para mais informações, consulte o artigo Adicione uma associação de políticas de gestão de identidades e acessos

Configure a autenticação através de cabeçalhos

O exemplo seguinte mostra como configurar a autenticação através de uma função. A função devolve um objeto JSON que contém os cabeçalhos necessários para fazer um pedido ao modelo de incorporação.

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

Substitua o seguinte:

  • HEADER_GEN_FUNCTION: o nome da função de geração de cabeçalhos que pode usar quando regista um modelo.
  • API_KEY: a chave da API do fornecedor do modelo.

Modelos de incorporação de texto

Esta secção mostra como registar pontos finais de modelos com a gestão de pontos finais de modelos.

A gestão de pontos finais de modelos suporta alguns modelos de incorporação de texto e modelos genéricos da Vertex AI como pontos finais de modelos pré-registados. Pode usar diretamente o ID do modelo para gerar incorporações ou invocar previsões, com base no tipo de modelo. Para mais informações sobre os modelos pré-registados suportados, consulte o artigo Modelos do Vertex AI pré-registados.

O modelo gemini-embedding-001 só está disponível na região us-central1.

Por exemplo, para chamar o modelo gemini-embedding-001 pré-registado, pode chamar diretamente o modelo através da função de incorporação:

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

Se o cluster do AlloyDB e o ponto final do Vertex AI estiverem em projetos diferentes, defina o model_id para o caminho qualificado do ponto final, por exemplo, projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/gemini-embedding-001.

Da mesma forma, para chamar o modelo gemini-1.5-pro:generateContent pré-registado, pode chamar diretamente o modelo através da função de previsão:

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

Para gerar incorporações, veja como gerar incorporações de texto. Para invocar previsões, veja como invocar previsões.

Modelos de incorporação de texto com suporte integrado

A gestão de pontos finais de modelos oferece suporte integrado para alguns modelos do Vertex AI e da OpenAI. Para ver a lista de modelos com suporte integrado, consulte o artigo Modelos com suporte integrado.

Para modelos com suporte integrado, pode definir o nome qualificado como o nome qualificado do modelo e especificar o URL do pedido. A gestão de pontos finais de modelos identifica automaticamente o modelo e configura as funções de transformação predefinidas.

Modelos de incorporação da Vertex AI

Os passos seguintes mostram como registar modelos do Vertex AI com suporte integrado. O ponto final do modelo gemini-embedding-001 e text-multilingual-embedding-002 é usado como exemplo.

Certifique-se de que o cluster do AlloyDB e o modelo do Vertex AI que está a consultar estão na mesma região.

  1. Associe à sua base de dados através do psql.

  2. Configure a extensão google_ml_integration.

  3. Chame a função de criação de modelos para adicionar o ponto final do modelo:

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

Se o modelo estiver armazenado num projeto e numa região diferentes do cluster do AlloyDB, defina o URL do pedido como projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/MODEL_ID, em que REGION_ID é a região onde o modelo está alojado e MODEL_ID é o nome do modelo qualificado.

Além disso, conceda a função de utilizador do Vertex AI (roles/aiplatform.user) à conta de serviço do AlloyDB do projeto onde a instância do AlloyDB reside, para que o AlloyDB possa aceder ao modelo alojado no outro projeto.

Abrir modelo de incorporação de texto de IA

A extensão google_ml_integration configura automaticamente as funções de transformação predefinidas e invoca chamadas para os modelos OpenAI remotos. Para ver a lista de modelos da OpenAI com suporte integrado, consulte o artigo Modelos com suporte integrado.

O exemplo seguinte adiciona o ponto final do modelo text-embedding-ada-002 OpenAI. Pode registar os pontos finais do modelo text-embedding-3-small e text-embedding-3-large da OpenAI através dos mesmos passos e definindo os nomes qualificados do modelo específicos dos modelos.

  1. Associe à sua base de dados através do psql.
  2. Configure a extensão google_ml_integration.
  3. Adicione a chave da API OpenAI como um segredo ao Secret Manager para autenticação.

  4. Chame o segredo armazenado no 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');

    Substitua o seguinte:

    • SECRET_ID: o ID secreto que define e que é usado posteriormente quando regista um ponto final do modelo, por exemplo, key1.
    • SECRET_MANAGER_SECRET_ID: o ID secreto definido no Secret Manager quando criou o segredo.
    • PROJECT_ID: o ID do seu projeto Google Cloud .
    • VERSION_NUMBER: o número da versão do ID secreto.

  5. Chame a função de criação de modelos para registar o ponto final do modelo 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');

    Substitua o seguinte:

    • MODEL_ID: um ID exclusivo para o ponto final do modelo que define. Este ID do modelo é referenciado para metadados que o ponto final do modelo precisa para gerar incorporações ou invocar previsões.
    • SECRET_ID: o ID secreto que usou anteriormente no procedimento google_ml.create_sm_secret().

Para gerar incorporações, consulte o artigo Gere incorporações de texto.

Modelo de incorporação de texto alojado de forma personalizada

Esta secção mostra como registar um ponto final de modelo alojado de forma personalizada, juntamente com a criação de funções de transformação e, opcionalmente, cabeçalhos HTTP personalizados. Todos os pontos finais de modelos alojados de forma personalizada são suportados, independentemente do local onde estão alojados.

O exemplo seguinte adiciona o ponto final do modelo personalizado custom-embedding-model alojado pela Cymbal. As funções de transformação cymbal_text_input_transform e cymbal_text_output_transform são usadas para transformar o formato de entrada e saída do modelo no formato de entrada e saída da função de previsão.

Para registar pontos finais de modelos de incorporação de texto alojados de forma personalizada, conclua os seguintes passos:

  1. Associe à sua base de dados através do psql.

  2. Configure a extensão google_ml_integration.

  3. Opcional: adicione a chave da API como um segredo ao Secret Manager para autenticação.

  4. Chame o segredo armazenado no 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');

    Substitua o seguinte:

    • SECRET_ID: o ID secreto que define e que é usado posteriormente quando regista um ponto final do modelo, por exemplo, key1.
    • SECRET_MANAGER_SECRET_ID: o ID secreto definido no Secret Manager quando criou o segredo.
    • PROJECT_ID: o ID do seu projeto Google Cloud .
    • VERSION_NUMBER: o número da versão do ID secreto.

  5. Crie as funções de transformação de entrada e saída com base na seguinte assinatura para a função de previsão para os pontos finais do modelo de incorporação de texto. Para mais informações sobre como criar funções de transformação, consulte o exemplo de funções de transformação.

    Seguem-se exemplos de funções de transformação específicas do custom-embedding-model ponto final do modelo de incorporação de texto:

    -- 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. Chame a função de criação de modelos para registar o ponto final do modelo de incorporação personalizado:

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

    Substitua o seguinte:

    • MODEL_ID: obrigatório. Um ID exclusivo para o ponto final do modelo que define, por exemplo, custom-embedding-model. Este ID do modelo é referenciado para metadados que o ponto final do modelo precisa para gerar incorporações ou invocar previsões.
    • REQUEST_URL: obrigatório. O ponto final específico do modelo quando adiciona incorporação de texto personalizada e pontos finais de modelos genéricos, por exemplo, https://cymbal.com/models/text/embeddings/v1. Certifique-se de que o ponto final do modelo é acessível através de um endereço IP interno. A gestão de pontos finais de modelos não suporta endereços IP públicos.
    • MODEL_QUALIFIED_NAME: obrigatório se o ponto final do modelo usar um nome qualificado. O nome totalmente qualificado, caso o ponto final do modelo tenha várias versões.
    • SECRET_ID: o ID secreto que usou anteriormente no procedimento google_ml.create_sm_secret().

Modelo multimodal com suporte integrado

Faça a integração com o Vertex AI e instale a extensão

  1. Integre com o Vertex AI.
  2. Certifique-se de que tem instalada a versão mais recente do google_ml_integration.

    1. Para verificar a versão instalada, execute o seguinte comando:

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

    2. Se a extensão não estiver instalada ou se a versão instalada for anterior à 1.4.3, atualize a extensão executando os seguintes comandos:

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

      Se tiver problemas quando executar os comandos anteriores ou se a extensão não for atualizada para a versão 1.4.3 depois de executar os comandos anteriores, contacte o apoio técnico do AlloyDB.

    3. Depois de se certificar de que a versão está atualizada, instale a funcionalidade de pré-visualização executando o procedimento 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)

Chame o modelo para gerar incorporações multimodais

Uma vez que a gestão de pontos finais de modelos oferece suporte integrado para o modelo multimodalembedding@001 da Vertex AI, pode chamar diretamente o modelo para gerar incorporações multimodais.

O exemplo seguinte usa o multimodalembedding@001nome do modelo qualificado como ID do modelo para gerar incorporações de imagens multimodais:

  1. Associe à sua base de dados através do psql.
  2. Configure a extensão google_ml_integration.

  3. Gerar incorporações de imagens multimodais:

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

Substitua o seguinte:

  • IMAGE_PATH_OR_TEXT com o caminho do Cloud Storage para a imagem, por exemplo, gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg para traduzir num encaixe vetorial ou numa string base64 da imagem.
  • MIMETYPE com o tipo MIME da imagem.

Modelos de classificação

Modelos de classificação do Vertex AI

Pode usar os modelos do Vertex AI mencionados em Modelos suportados sem registo.

Para saber como classificar os resultados da pesquisa através de um modelo de classificação da Vertex AI, consulte o artigo Classifique os resultados da pesquisa.

Registar um modelo de classificação de terceiros

O exemplo seguinte mostra como registar um modelo de reclassificação da 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'
  );

Modelos genéricos

Esta secção mostra como registar qualquer ponto final de modelo genérico que esteja disponível num fornecedor de modelos alojados, como o Hugging Face, a OpenAI, a Vertex AI, a Anthropic ou qualquer outro fornecedor. Esta secção mostra exemplos para registar um ponto final de modelo genérico alojado no Hugging Face, um modelo genérico gemini-pro do Model Garden do Vertex AI e o ponto final de modelo claude-haiku.

Pode registar qualquer ponto final de modelo genérico, desde que a entrada e a saída estejam no formato JSON. Com base nos metadados do ponto final do modelo, pode ter de gerar cabeçalhos HTTP ou definir URLs de pedidos.

Para mais informações sobre modelos genéricos pré-registados e modelos com suporte integrado, consulte o artigo Modelos suportados.

Modelos genéricos do Gemini

Esta secção mostra como registar modelos genéricos do Gemini.

Modelo gemini-1.5-pro

Uma vez que alguns modelos gemini-pro estão pré-registados, pode chamar diretamente o ID do modelo para invocar previsões.

O exemplo seguinte usa o ponto final do modelo gemini-1.5-pro:generateContent do Vertex AI Model Garden.

  1. Associe à sua base de dados através do psql.
  2. Configure a extensão google_ml_integration.

  3. Invocar previsões através do ID do modelo pré-registado:

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

Modelo genérico no Hugging Face

O exemplo seguinte adiciona o ponto final do modelo de classificação personalizada facebook/bart-large-mnlialojado no Hugging Face.

  1. Associe à sua base de dados através do psql.
  2. Configure a extensão google_ml_integration.
  3. Adicione a chave da API OpenAI como um segredo ao Secret Manager para autenticação. Se já tiver criado um segredo para qualquer outro modelo da OpenAI, pode reutilizar o mesmo segredo.

  4. Chame o segredo armazenado no 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');

    Substitua o seguinte:

    • SECRET_ID: o ID secreto que define e que é usado posteriormente quando regista um ponto final do modelo.
    • SECRET_MANAGER_SECRET_ID: o ID secreto definido no Secret Manager quando criou o segredo.
    • PROJECT_ID: o ID do seu projeto Google Cloud .
    • VERSION_NUMBER: o número da versão do ID secreto.

  5. Chame a função de criação de modelos para registar o ponto final do modelo 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');

    Substitua o seguinte:

    • MODEL_ID: um ID exclusivo para o ponto final do modelo que define, por exemplo, custom-classification-model. Este ID do modelo é referenciado para metadados que o ponto final do modelo precisa para gerar incorporações ou invocar previsões.
    • REQUEST_URL: o ponto final específico do modelo quando adiciona incorporação de texto personalizada e pontos finais de modelos genéricos, por exemplo, https://api-inference.huggingface.co/models/facebook/bart-large-mnli.
    • MODEL_QUALIFIED_NAME: o nome totalmente qualificado da versão do ponto final do modelo, por exemplo, facebook/bart-large-mnli.
    • SECRET_ID: o ID secreto que usou anteriormente no procedimento google_ml.create_sm_secret().

Modelo genérico da Anthropic

O exemplo seguinte adiciona o ponto final do modelo claude-3-opus-20240229. A gestão de pontos finais de modelos fornece a função de cabeçalho necessária para registar modelos da Anthropic.

  1. Associe à sua base de dados através do psql.

  2. Crie e ative a extensão google_ml_integration.

    Secret Manager

    1. Adicione o token de portador como um segredo ao Secret Manager para autenticação.

    2. Chame o segredo armazenado no 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');

      Substitua o seguinte:

      • SECRET_ID: o ID secreto que define e que é usado posteriormente quando regista um ponto final do modelo.
      • SECRET_MANAGER_SECRET_ID: o ID secreto definido no Secret Manager quando criou o segredo.
      • PROJECT_ID: o ID do seu projeto Google Cloud .
      • VERSION_NUMBER: o número da versão do ID secreto.

    3. Chame a função de criação de modelos para registar o ponto final do modelo 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');

      Substitua o seguinte:

      • MODEL_ID: um ID exclusivo para o ponto final do modelo que define, por exemplo, anthropic-opus. Este ID do modelo é referenciado para metadados que o ponto final do modelo precisa para gerar incorporações ou invocar previsões.
      • REQUEST_URL: o ponto final específico do modelo quando adiciona incorporação de texto personalizada e pontos finais de modelos genéricos, por exemplo, https://api.anthropic.com/v1/messages.

    Cabeçalho de autorização

    1. Use a função de geração de cabeçalhos predefinida google_ml.anthropic_claude_header_gen_fn ou crie uma função de geração de cabeçalhos.

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

      Substitua o seguinte:

      • ANTHROPIC_API_KEY: a chave da API da Anthropic.
      • ANTHROPIC_VERSION (Opcional): a versão específica do modelo que quer usar, por exemplo, 2023-06-01.

    2. Chame a função de criação de modelos para registar o ponto final do modelo 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');

      Substitua o seguinte:

      • MODEL_ID: um ID exclusivo para o ponto final do modelo que define, por exemplo, anthropic-opus. Este ID do modelo é referenciado para metadados que o ponto final do modelo precisa para gerar incorporações ou invocar previsões.
      • REQUEST_URL: o ponto final específico do modelo quando adiciona incorporação de texto personalizada e pontos finais de modelos genéricos, por exemplo, https://api.anthropic.com/v1/messages.

Para mais informações, veja como invocar previsões para pontos finais de modelos genéricos.

O que se segue?