Registrar y llamar a modelos de IA remotos mediante la gestión de endpoints de modelos

En esta página se describe cómo invocar predicciones o generar inserciones mediante un modelo registrando el endpoint del modelo con la gestión de endpoints de modelos.

Antes de empezar

Configurar la extensión

  1. Conéctate a tu base de datos mediante psql o AlloyDB para PostgreSQL Studio con el usuario postgres.

  2. Opcional: Solicita acceso para interactuar con las funciones del motor de consultas de IA de AlloyDB para PostgreSQL (vista previa), como la compatibilidad con modelos multimodales, modelos de clasificación y funciones de operador.

  3. Opcional: Concede permiso a un usuario de PostgreSQL que no sea superadministrador para gestionar los metadatos del modelo:

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

    Sustituye la siguiente variable:

    • NON_SUPER_USER: el nombre de usuario de PostgreSQL que no es superusuario.

  4. Asegúrate de que la IP saliente esté habilitada para acceder a modelos alojados fuera de tu VPC, como modelos de terceros. Para obtener más información, consulta Añadir conectividad saliente.

Configurar la autenticación

En las siguientes secciones se muestra cómo configurar la autenticación antes de registrar un endpoint de modelo.

Configurar la autenticación de Vertex AI

Para usar los endpoints de modelos de Google Vertex AI, debes añadir permisos de Vertex AI a la cuenta de servicio de AlloyDB basada en IAM que uses para conectarte a la base de datos. Para obtener más información sobre la integración con Vertex AI, consulta Integración con Vertex AI.

Configurar la autenticación con Secret Manager

En esta sección se explica cómo configurar la autenticación si usas Secret Manager para almacenar los detalles de autenticación de proveedores externos.

Este paso es opcional si tu endpoint de modelo no gestiona la autenticación a través de Secret Manager. Por ejemplo, si tu endpoint de modelo usa encabezados HTTP para transferir información de autenticación o no usa la autenticación.

Para crear y usar una clave de API o un token de portador, sigue estos pasos:

  1. Crea el secreto en Secret Manager. Para obtener más información, consulta Crear un secreto y acceder a una versión de un secreto.

    La ruta del secreto se usa en la función SQL google_ml.create_sm_secret().

  2. Concede permisos al clúster de AlloyDB para acceder al secreto.

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

    Haz los cambios siguientes:

    • SECRET_NAME: el nombre del secreto en Secret Manager.

    • SERVICE_ACCOUNT_ID: el ID de la cuenta de servicio basada en gestión de identidades y accesos en formato serviceAccount:service-PROJECT_ID@gcp-sa-alloydb.iam.gserviceaccount.com. Por ejemplo, service-212340152456@gcp-sa-alloydb.iam.gserviceaccount.com.

      También puede asignar este rol a la cuenta de servicio a nivel de proyecto. Para obtener más información, consulta Añadir una vinculación de política de Gestión de Identidades y Accesos.

Configurar la autenticación mediante encabezados

En el siguiente ejemplo se muestra cómo configurar la autenticación mediante una función. La función devuelve un objeto JSON que contiene los encabezados necesarios para hacer una solicitud al modelo de inserción.

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

Haz los cambios siguientes:

  • HEADER_GEN_FUNCTION: el nombre de la función de generación de encabezados que puedes usar al registrar un modelo.
  • API_KEY: la clave de API del proveedor del modelo.

Modelos de inserción de texto

En esta sección se muestra cómo registrar endpoints de modelos con la gestión de endpoints de modelos.

La gestión de endpoints de modelos admite algunos modelos de inserción de texto y modelos genéricos de Vertex AI como endpoints de modelos pre-registrados. Puedes usar directamente el ID del modelo para generar inserciones o invocar predicciones, en función del tipo de modelo. Para obtener más información sobre los modelos pre-registrados admitidos, consulta Modelos de Vertex AI pre-registrados.

El modelo gemini-embedding-001 solo está disponible en la región us-central1.

Por ejemplo, para llamar al modelo gemini-embedding-001 registrado previamente, puedes llamar directamente al modelo mediante la función de inserción:

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

Si tu clúster de AlloyDB y el endpoint de Vertex AI están en proyectos diferentes, asigna a model_id la ruta cualificada del endpoint (por ejemplo, projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/gemini-embedding-001).

Del mismo modo, para llamar al modelo gemini-1.5-pro:generateContent registrado previamente, puedes llamar directamente al modelo mediante la función de predicción:

 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 generar incrustaciones, consulta cómo generar incrustaciones de texto. Para invocar predicciones, consulta cómo invocar predicciones.

Modelos de inserción de texto con asistencia integrada

La gestión de endpoints de modelos ofrece compatibilidad integrada con algunos modelos de Vertex AI y OpenAI. Para ver la lista de modelos con compatibilidad integrada, consulta Modelos con compatibilidad integrada.

En los modelos con asistencia integrada, puedes definir el nombre cualificado como el nombre cualificado del modelo y especificar la URL de la solicitud. La gestión de endpoints de modelos identifica automáticamente el modelo y configura las funciones de transformación predeterminadas.

Modelos de inserciones de Vertex AI

En los siguientes pasos se muestra cómo registrar modelos de Vertex AI con asistencia integrada. Se usa como ejemplo el endpoint del modelo gemini-embedding-001 y text-multilingual-embedding-002.

Asegúrate de que tanto el clúster de AlloyDB como el modelo de Vertex AI que estás consultando se encuentren en la misma región.

  1. Conéctate a tu base de datos con psql.

  2. Configura la extensión google_ml_integration.

  3. Llama a la función de creación de modelos para añadir el endpoint del 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');

Si el modelo se almacena en otro proyecto y región que tu clúster de AlloyDB, define la URL de la solicitud como projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/MODEL_ID, donde REGION_ID es la región en la que se aloja tu modelo y MODEL_ID es el nombre cualificado del modelo.

Además, concede el rol Usuario de Vertex AI (roles/aiplatform.user) a la cuenta de servicio de AlloyDB del proyecto en el que se encuentra la instancia de AlloyDB para que AlloyDB pueda acceder al modelo alojado en el otro proyecto.

Modelo de inserción de texto de Open AI

La extensión google_ml_integration configura automáticamente las funciones de transformación predeterminadas e invoca llamadas a los modelos remotos de OpenAI. Para ver la lista de modelos de OpenAI con compatibilidad integrada, consulta Modelos con compatibilidad integrada.

En el siguiente ejemplo se añade el endpoint del modelo text-embedding-ada-002 de OpenAI. Puedes registrar los endpoints de los modelos text-embedding-3-small y text-embedding-3-large de OpenAI siguiendo los mismos pasos y definiendo los nombres cualificados de los modelos.

  1. Conéctate a tu base de datos con psql.
  2. Configura la extensión google_ml_integration.
  3. Añade la clave de API de OpenAI como secreto a Secret Manager para la autenticación.

  4. Llama al secreto almacenado en 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');

    Haz los cambios siguientes:

    • SECRET_ID: el ID secreto que has definido y que se usa posteriormente al registrar un endpoint de modelo. Por ejemplo, key1.
    • SECRET_MANAGER_SECRET_ID: el ID de secreto definido en Secret Manager al crear el secreto.
    • PROJECT_ID: el ID de tu proyecto de Google Cloud .
    • VERSION_NUMBER: el número de versión del ID del secreto.

  5. Llama a la función de creación de modelos para registrar el endpoint del 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');

    Haz los cambios siguientes:

    • MODEL_ID: un ID único para el endpoint del modelo que definas. Este ID de modelo se utiliza como referencia para los metadatos que necesita el endpoint del modelo para generar inserciones o invocar predicciones.
    • SECRET_ID: el ID secreto que has usado anteriormente en el procedimiento de google_ml.create_sm_secret().

Para generar incrustaciones, consulta Generar incrustaciones de texto.

Modelo de inserción de texto alojado de forma personalizada

En esta sección se muestra cómo registrar un endpoint de modelo alojado de forma personalizada, así como crear funciones de transformación y, opcionalmente, encabezados HTTP personalizados. Se admiten todos los endpoints de modelos alojados de forma personalizada, independientemente de dónde estén alojados.

En el siguiente ejemplo se añade el endpoint del modelo personalizado custom-embedding-model alojado en Cymbal. Las funciones de transformación cymbal_text_input_transform y cymbal_text_output_transform se usan para transformar el formato de entrada y salida del modelo en el formato de entrada y salida de la función de predicción.

Para registrar endpoints de modelos de inserción de texto alojados de forma personalizada, sigue estos pasos:

  1. Conéctate a tu base de datos con psql.

  2. Configura la extensión google_ml_integration.

  3. Opcional: Añade la clave de API como secreto a Secret Manager para la autenticación.

  4. Llama al secreto almacenado en 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');

    Haz los cambios siguientes:

    • SECRET_ID: el ID secreto que has definido y que se usa posteriormente al registrar un endpoint de modelo. Por ejemplo, key1.
    • SECRET_MANAGER_SECRET_ID: el ID de secreto definido en Secret Manager al crear el secreto.
    • PROJECT_ID: el ID de tu proyecto de Google Cloud .
    • VERSION_NUMBER: el número de versión del ID del secreto.

  5. Crea las funciones de transformación de entrada y salida a partir de la siguiente firma de la función de predicción de los endpoints del modelo de inserción de texto. Para obtener más información sobre cómo crear funciones de transformación, consulta el ejemplo de funciones de transformación.

    A continuación, se muestran funciones de transformación de ejemplo específicas del endpoint del modelo de inserciones de texto 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. Llama a la función de creación de modelos para registrar el endpoint del modelo de inserción 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');

    Haz los cambios siguientes:

    • MODEL_ID: obligatorio. Un ID único para el endpoint del modelo que definas (por ejemplo, custom-embedding-model). Este ID de modelo se utiliza como referencia para los metadatos que necesita el endpoint del modelo para generar inserciones o invocar predicciones.
    • REQUEST_URL: obligatorio. El endpoint específico del modelo al añadir una inserción de texto personalizada y endpoints de modelos genéricos (por ejemplo, https://cymbal.com/models/text/embeddings/v1). Asegúrate de que se pueda acceder al endpoint del modelo a través de una dirección IP interna. La gestión de endpoints de modelos no admite direcciones IP públicas.
    • MODEL_QUALIFIED_NAME: es obligatorio si el endpoint de tu modelo usa un nombre cualificado. El nombre completo en caso de que el endpoint del modelo tenga varias versiones.
    • SECRET_ID: el ID secreto que has usado anteriormente en el procedimiento de google_ml.create_sm_secret().

Modelo multimodal con asistencia integrada

Integrar con Vertex AI e instalar la extensión

  1. Integración con Vertex AI.
  2. Asegúrate de que esté instalada la versión más reciente de google_ml_integration.

    1. Para comprobar la versión instalada, ejecuta el siguiente comando:

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

    2. Si la extensión no está instalada o la versión instalada es anterior a la 1.4.3, actualízala ejecutando los siguientes comandos:

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

      Si tienes problemas al ejecutar los comandos anteriores o si la extensión no se actualiza a la versión 1.4.3 después de ejecutar los comandos anteriores, ponte en contacto con el equipo de Asistencia de AlloyDB.

    3. Una vez que te hayas asegurado de que la versión está actualizada, instala la función de vista previa ejecutando el procedimiento 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)

Llama al modelo para generar inserciones multimodales

Como la gestión de endpoints de modelos ofrece compatibilidad integrada con el modelo multimodalembedding@001 de Vertex AI, puedes llamar directamente al modelo para generar embeddings multimodales.

En el siguiente ejemplo se usa el nombre de modelo cualificado multimodalembedding@001 como ID de modelo para generar inserciones de imágenes multimodales:

  1. Conéctate a tu base de datos con psql.
  2. Configura la extensión google_ml_integration.

  3. Genera incrustaciones de imágenes multimodales:

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

Haz los cambios siguientes:

  • IMAGE_PATH_OR_TEXT con la ruta de Cloud Storage de la imagen, por ejemplo, gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg para traducir a una incrustación vectorial o una cadena base64 de la imagen.
  • MIMETYPE con el tipo MIME de la imagen.

Modelos de clasificación

Modelos de clasificación de Vertex AI

Puedes usar los modelos de Vertex AI que se mencionan en Modelos admitidos sin registrarte.

Para saber cómo clasificar los resultados de búsqueda con un modelo de clasificación de Vertex AI, consulta Clasificar resultados de búsqueda.

.

Registrar un modelo de ranking de terceros

En el siguiente ejemplo se muestra cómo registrar un modelo de reordenación de 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

En esta sección se muestra cómo registrar cualquier endpoint de modelo genérico que esté disponible en un proveedor de modelos alojado, como Hugging Face, OpenAI, Vertex AI, Anthropic o cualquier otro proveedor. En esta sección se muestran ejemplos para registrar un endpoint de modelo genérico alojado en Hugging Face, un modelo genérico gemini-pro de Vertex AI Model Garden y el endpoint de modelo claude-haiku.

Puedes registrar cualquier endpoint de modelo genérico siempre que la entrada y la salida estén en formato JSON. En función de los metadatos del endpoint del modelo, es posible que tengas que generar encabezados HTTP o definir URLs de solicitud.

Para obtener más información sobre los modelos genéricos prerregistrados y los modelos con asistencia integrada, consulta Modelos admitidos.

Modelos genéricos de Gemini

En esta sección se muestra cómo registrar modelos genéricos de Gemini.

Modelo gemini-1.5-pro

Como algunos modelos gemini-pro están pre-registrados, puedes llamar directamente al ID del modelo para invocar predicciones.

En el siguiente ejemplo se usa el endpoint del modelo gemini-1.5-pro:generateContent de Vertex AI Model Garden.

  1. Conéctate a tu base de datos con psql.
  2. Configura la extensión google_ml_integration.

  3. Invoca las predicciones con el ID del modelo prerregistrado:

    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 en Hugging Face

En el siguiente ejemplo se añade el endpoint del modelo de clasificación personalizado facebook/bart-large-mnli alojado en Hugging Face.

  1. Conéctate a tu base de datos con psql.
  2. Configura la extensión google_ml_integration.
  3. Añade la clave de API de OpenAI como secreto a Secret Manager para la autenticación. Si ya has creado un secreto para otro modelo de OpenAI, puedes reutilizarlo.

  4. Llama al secreto almacenado en 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');

    Haz los cambios siguientes:

    • SECRET_ID: el ID secreto que has definido y que se usa posteriormente al registrar un endpoint de modelo.
    • SECRET_MANAGER_SECRET_ID: el ID de secreto definido en Secret Manager al crear el secreto.
    • PROJECT_ID: el ID de tu proyecto de Google Cloud .
    • VERSION_NUMBER: el número de versión del ID del secreto.

  5. Llama a la función de creación de modelos para registrar el endpoint del 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');

    Haz los cambios siguientes:

    • MODEL_ID: un ID único para el endpoint del modelo que definas (por ejemplo, custom-classification-model). Este ID de modelo se utiliza como referencia para los metadatos que necesita el endpoint del modelo para generar inserciones o invocar predicciones.
    • REQUEST_URL: el endpoint específico del modelo al añadir una inserción de texto personalizada y endpoints de modelos genéricos, como https://api-inference.huggingface.co/models/facebook/bart-large-mnli.
    • MODEL_QUALIFIED_NAME: nombre completo de la versión del endpoint del modelo (por ejemplo, facebook/bart-large-mnli).
    • SECRET_ID: el ID secreto que has usado anteriormente en el procedimiento de google_ml.create_sm_secret().

Modelo genérico de Anthropic

En el siguiente ejemplo se añade el endpoint del modelo claude-3-opus-20240229. La gestión de endpoints de modelos proporciona la función de encabezado necesaria para registrar modelos de Anthropic.

  1. Conéctate a tu base de datos con psql.

  2. Crea y habilita la extensión google_ml_integration.

    Secret Manager

    1. Añade el token de portador como secreto a Secret Manager para la autenticación.

    2. Llama al secreto almacenado en 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');

      Haz los cambios siguientes:

      • SECRET_ID: el ID secreto que has definido y que se usa posteriormente al registrar un endpoint de modelo.
      • SECRET_MANAGER_SECRET_ID: el ID de secreto definido en Secret Manager al crear el secreto.
      • PROJECT_ID: el ID de tu proyecto de Google Cloud .
      • VERSION_NUMBER: el número de versión del ID del secreto.

    3. Llama a la función de creación de modelos para registrar el endpoint del 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');

      Haz los cambios siguientes:

      • MODEL_ID: un ID único para el endpoint del modelo que definas (por ejemplo, anthropic-opus). Este ID de modelo se utiliza como referencia para los metadatos que necesita el endpoint del modelo para generar inserciones o invocar predicciones.
      • REQUEST_URL: el endpoint específico del modelo al añadir una inserción de texto personalizada y endpoints de modelos genéricos, como https://api.anthropic.com/v1/messages.

    Encabezado de autorización

    1. Usa la función de generación de encabezados predeterminada google_ml.anthropic_claude_header_gen_fn o crea una función de generación de encabezados.

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

      Haz los cambios siguientes:

      • ANTHROPIC_API_KEY: la clave de API de Anthropic.
      • ANTHROPIC_VERSION (opcional): la versión específica del modelo que quieras usar (por ejemplo, 2023-06-01).

    2. Llama a la función de creación de modelos para registrar el endpoint del 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');

      Haz los cambios siguientes:

      • MODEL_ID: un ID único para el endpoint del modelo que definas (por ejemplo, anthropic-opus). Este ID de modelo se utiliza como referencia para los metadatos que necesita el endpoint del modelo para generar inserciones o invocar predicciones.
      • REQUEST_URL: el endpoint específico del modelo al añadir una inserción de texto personalizada y endpoints de modelos genéricos, como https://api.anthropic.com/v1/messages.

Para obtener más información, consulte cómo invocar predicciones para endpoints de modelos genéricos.

Siguientes pasos