Se usó la API de Cloud Translation para traducir esta página.

Registra y llama a modelos de IA remotos con la administración de extremos de modelos
Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

En esta página, se describe cómo invocar predicciones o generar incorporaciones con un modelo mediante el registro del extremo del modelo con la administración de extremos de modelos.

Antes de comenzar

Antes de registrar un extremo de modelo con la administración de extremos de modelos, debes habilitar la extensión google_ml_integration y configurar la autenticación según el proveedor del modelo, si tu extremo de modelo requiere autenticación.

Asegúrate de acceder a tu base de datos con el nombre de usuario predeterminado de postgres.

Habilita la extensión

Debes agregar y habilitar la extensión google_ml_integration para poder comenzar a usar las funciones asociadas. La administración de extremos de modelos requiere que se instale la extensión google_ml_integration.

Verifica que la marca de base de datos google_ml_integration.enable_model_support esté configurada como on para una instancia. Para obtener más información sobre cómo configurar marcas de base de datos, consulta Configura las marcas de base de datos de una instancia.
Conéctate a tu base de datos con psql o AlloyDB para PostgreSQL Studio.

Agrega la extensión google_ml_integration con psql:

  CREATE EXTENSION IF NOT EXISTS google_ml_integration;

Opcional: Si la extensión google_ml_integration ya está instalada, cámbiala para actualizarla a la versión más reciente:
```
    ALTER EXTENSION google_ml_integration UPDATE;
```
Opcional: Solicita acceso para interactuar con las funciones del motor de consulta de IA de AlloyDB para PostgreSQL (versión preliminar), incluida la compatibilidad con modelos multimodales, modelos de clasificación y funciones de operador.
Opcional: Otorga permiso a un usuario de PostgreSQL que no sea superusuario para administrar los metadatos del modelo:
```
  GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA google_ml TO NON_SUPER_USER;
```
Reemplaza NON_SUPER_USER por el nombre de usuario de PostgreSQL que no sea superusuario.
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 Cómo agregar conectividad saliente.

Configura la autenticación

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

Configura la autenticación para Vertex AI

Para usar los extremos de modelos de Google Vertex AI, debes agregar permisos de Vertex AI a la cuenta de servicio de AlloyDB basada en IAM que usas 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.

Configura la autenticación con Secret Manager

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

Este paso es opcional si el extremo de tu modelo no controla la autenticación a través de Secret Manager, por ejemplo, si el extremo de tu modelo usa encabezados HTTP para pasar información de autenticación o no usa autenticación en absoluto.

Para crear y usar una clave de API o un token portador, completa los siguientes pasos:

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

La ruta de acceso secreta se usa en la función SQL google_ml.create_sm_secret().
Otorga 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"
```
Reemplaza lo siguiente:
- SECRET_NAME: Es el nombre del Secret en Secret Manager.
- SERVICE_ACCOUNT_ID: Es el ID de la cuenta de servicio basada en IAM en el formato serviceAccount:service-PROJECT_ID@gcp-sa-alloydb.iam.gserviceaccount.com, por ejemplo, service-212340152456@gcp-sa-alloydb.iam.gserviceaccount.com.
  
  También puedes otorgar este rol a la cuenta de servicio a nivel del proyecto. Para obtener más información, consulta Cómo agregar una vinculación de políticas de Identity and Access Management.

Configura la autenticación con encabezados

En el siguiente ejemplo, se muestra cómo configurar la autenticación con una función. La función muestra un objeto JSON que contiene los encabezados necesarios para realizar una solicitud al modelo de incorporació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;
  $$;

Reemplaza lo siguiente:

HEADER_GEN_FUNCTION: Es el nombre de la función de generación de encabezados que puedes usar cuando registras un modelo.
API_KEY: La clave de API del proveedor del modelo.

Modelos de incorporación de texto

En esta sección, se muestra cómo registrar extremos de modelos con la administración de extremos de modelos.

La administración de extremos de modelos admite algunos modelos genéricos de Vertex AI y de incorporación de texto como extremos de modelos registrados previamente. Puedes usar directamente el ID del modelo para generar incorporaciones o invocar predicciones, según el tipo de modelo. Para obtener más información sobre los modelos registrados previamente admitidos, consulta Modelos de Vertex AI registrados previamente.

El modelo text-embedding-large-exp-03-07 solo está disponible en la región us-central1.

Por ejemplo, para llamar al modelo text-embedding-large-exp-03-07 registrado previamente, puedes llamarlo directamente con la función de incorporación:

SELECT
      embedding(
        model_id => 'text-embedding-large-exp-03-07',
        content => 'AlloyDB is a managed, cloud-hosted SQL database service');

De manera similar, para llamar al modelo gemini-1.5-pro:generateContent registrado previamente, puedes llamarlo directamente con 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 incorporaciones, consulta cómo generar incorporaciones para extremos de modelos registrados previamente. Para invocar predicciones, consulta cómo invocar predicciones para extremos de modelos registrados previamente.

Modelos de incorporación de texto con compatibilidad integrada

La administración de extremos de modelos proporciona compatibilidad integrada para algunos modelos de Vertex AI y OpenAI. Para obtener la lista de modelos con compatibilidad integrada, consulta Modelos con compatibilidad integrada.

En el caso de los modelos con compatibilidad integrada, puedes establecer el nombre calificado como el nombre calificado del modelo y especificar la URL de la solicitud. La administración de extremos de modelos identifica automáticamente el modelo y configura las funciones de transformación predeterminadas.

Modelos de incorporación de Vertex AI

En los siguientes pasos, se muestra cómo registrar modelos de Vertex AI con compatibilidad integrada. Se usan como ejemplo el extremo del modelo text-embedding-005 y text-multilingual-embedding-002.

Asegúrate de que el clúster de AlloyDB y el modelo de Vertex AI que consultas estén en la misma región.

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.

Llama a la función de creación de modelos para agregar el extremo del modelo:

text-embedding-005

  CALL
    google_ml.create_model(
      model_id => 'text-embedding-005',
      model_request_url => 'publishers/google/models/text-embedding-005',
      model_provider => 'google',
      model_qualified_name => 'text-embedding-005',
      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 no es tu clúster de AlloyDB, establece la URL de la solicitud en 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 del modelo calificado.

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

Modelo de incorporación de texto de Open AI

La extensión google_ml_integration configura automáticamente las funciones de transformación predeterminadas y, además, 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 agrega el extremo del modelo text-embedding-ada-002 de OpenAI. Puedes registrar los extremos de los modelos text-embedding-3-small y text-embedding-3-large de OpenAI con los mismos pasos y establecer los nombres calificados de los modelos específicos para los modelos.

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.
Agrega la clave de API de OpenAI como un secreto a Secret Manager para la autenticación.
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');
```
Reemplaza lo siguiente:
- SECRET_ID: Es el ID secreto que estableces y que se usa posteriormente cuando registras un extremo de modelo, por ejemplo, key1.
- SECRET_MANAGER_SECRET_ID: Es el ID de secreto establecido en Secret Manager cuando creaste el secreto.
- PROJECT_ID: Es el ID de tu Google Cloud proyecto.
- VERSION_NUMBER: El número de versión del ID secreto.
Llama a la función de creación de modelos para registrar el extremo 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');
```
Reemplaza lo siguiente:
- MODEL_ID: Un ID único para el extremo del modelo que definas. Se hace referencia a este ID de modelo para los metadatos que el extremo del modelo necesita para generar incorporaciones o invocar predicciones.
- SECRET_ID: Es el ID secreto que usaste antes en el procedimiento google_ml.create_sm_secret().

Para generar incorporaciones, consulta cómo generar incorporaciones para extremos de modelos con compatibilidad integrada.

Modelo de incorporación de texto alojado de forma personalizada

En esta sección, se muestra cómo registrar un extremo de modelo alojado de forma personalizada junto con la creación de funciones de transformación y, de forma opcional, encabezados HTTP personalizados. Se admiten todos los extremos de modelos alojados de forma personalizada, independientemente de dónde se alojen.

En el siguiente ejemplo, se agrega el extremo de modelo personalizado custom-embedding-model alojado por 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 al formato de entrada y salida de la función de predicción.

Para registrar extremos de modelos de incorporación de texto alojados de forma personalizada, completa los siguientes pasos:

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.
Opcional: Agrega la clave de API como un secreto a Secret Manager para la autenticación.
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');
```
Reemplaza lo siguiente:
- SECRET_ID: Es el ID secreto que estableces y que se usa posteriormente cuando registras un extremo de modelo, por ejemplo, key1.
- SECRET_MANAGER_SECRET_ID: Es el ID de secreto establecido en Secret Manager cuando creaste el secreto.
- PROJECT_ID: Es el ID de tu Google Cloud proyecto.
- VERSION_NUMBER: El número de versión del ID secreto.
Nota: Secret Manager genera un encabezado Authorization: Bearer SECRET_VALUE_FROM_SECRET_MANAGER para la autenticación de forma predeterminada. Si este formato coincide con el formato del token de portador de autorización del extremo de tu modelo, no es necesario que generes encabezados de autorización con la función de generación de encabezados.

Crea las funciones de transformación de entrada y salida según la siguiente firma para la función de predicción de los extremos del modelo de incorporació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.

Los siguientes son ejemplos de funciones de transformación específicas del extremo del modelo de incorporación 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;
$$;

Llama a la función de creación de modelos para registrar el extremo del modelo de incorporació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');
```
Reemplaza lo siguiente:
- MODEL_ID: Obligatorio. Un ID único para el extremo del modelo que definas, por ejemplo, custom-embedding-model. Se hace referencia a este ID de modelo para los metadatos que el extremo del modelo necesita para generar incorporaciones o invocar predicciones.
- REQUEST_URL: Obligatorio. Es el extremo específico del modelo cuando se agregan incorporaciones de texto personalizadas y extremos de modelos genéricos, por ejemplo, https://cymbal.com/models/text/embeddings/v1. Asegúrate de que se pueda acceder al extremo del modelo a través de una dirección IP interna. La administración de extremos de modelos no admite direcciones IP públicas.
- MODEL_QUALIFIED_NAME: Es obligatorio si el extremo de tu modelo usa un nombre calificado. Es el nombre completamente calificado en caso de que el extremo del modelo tenga varias versiones.
- SECRET_ID: Es el ID secreto que usaste antes en el procedimiento google_ml.create_sm_secret().

Modelo multimodal con compatibilidad integrada

Dado que la administración de extremos de modelos proporciona compatibilidad integrada con el modelo multimodalembedding@001 de Vertex AI, puedes llamar directamente al ID del modelo para generar incorporaciones multimodales.

En el siguiente ejemplo, se usa el nombre del modelo calificado multimodalembedding@001 como ID del modelo para generar incorporaciones de imágenes multimodales:

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.

Genera incorporaciones de imágenes multimodales:

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

Reemplaza lo siguiente:

IMAGE_PATH_OR_TEXT con la ruta de acceso a la imagen de Cloud Storage, por ejemplo, gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg, para traducirla en una incorporación de vectores o una cadena de base64 de la imagen.
MIMETYPE con el tipo de MIME de la imagen.

Modelos de clasificación

En esta sección, se muestra cómo registrar el modelo de clasificación semantic-ranker-512-002 de Vertex AI con compatibilidad integrada. Tanto los modelos semantic-ranker-512-002 como semantic-ranker-512-003 tienen compatibilidad integrada.

Modelos de clasificación de Vertex AI

En esta sección, se muestra cómo registrar extremos de clasificación con la administración de extremos de modelos.

Para registrar los extremos del modelo semantic-ranker-512-002, completa los siguientes pasos:

Crea una cuenta de servicio independiente de la cuenta de servicio de AlloyDB.
Habilita la API de Discovery Engine en el proyecto en el que registras el extremo del modelo de clasificación.
Otorga los siguientes roles a la cuenta de servicio:
- Discovery Engine Admin (roles/discoveryengine.admin)
- Vertex AI Administrator (roles/aiplatform.admin)
Otorga los siguientes roles de cuenta de servicio a la cuenta de servicio:
- Service Account Token Creator role (roles/iam.serviceAccountTokenCreator)
- Service Account User role (roles/iam.serviceAccountUser)
Genera un token de acceso para la cuenta de servicio con una duración más larga.
```
gcloud auth print-access-token \
  --impersonate-service-account="service-PROJECT_NUMBER@gcp-sa-alloydb.iam.gserviceaccount.com" \
  --lifetime=43200
```
Nota: La duración máxima del secreto suplantado es de 12 horas. Debes rotar el secreto y actualizarlo después de este período para que se pueda acceder al extremo de forma continua.
Agrega el token de autenticación generado como secreto a Secret Manager para la autenticación.
Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.
Crea un 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/latest;
```
Reemplaza lo siguiente:
- SECRET_ID: Es el ID secreto que estableces y que se usa posteriormente cuando registras un extremo de modelo, por ejemplo, key1.
- SECRET_MANAGER_SECRET_ID: Es el ID de secreto establecido en Secret Manager cuando creaste el secreto.
- PROJECT_ID: Es el ID de tu Google Cloud proyecto.
- VERSION_NUMBER: El número de versión del ID secreto. Como se usa la versión más reciente del secreto, cuando venza tu token secreto y lo actualices en Secret Manager, no necesitarás volver a actualizar la versión en AlloyDB.

Llama a la función de creación de modelos para agregar el extremo del modelo:

    CALL
      google_ml.create_model(
        model_id => 'semantic-ranker-512-002',
        model_type => 'reranking',
        model_provider => 'custom',
        model_request_url =>
          'https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/rankingConfigs/default_ranking_config:rank',
        model_qualified_name => 'semantic-ranker-512@002',
        model_auth_type => 'secret_manager',
        model_auth_id => 'SECRET_ID',
        model_in_transform_fn => 'google_ml.vertexai_reranking_input_transform',
        model_out_transform_fn => 'google_ml.vertexai_reranking_output_transform',
        generate_headers_fn => 'google_ml.vertexai_reranking_header_gen_fn');

Reemplaza PROJECT_ID por el ID de tu proyecto.

Modelos genéricos

En esta sección, se muestra cómo registrar cualquier extremo 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 extremo de modelo genérico alojado en Hugging Face, un modelo gemini-pro genérico de Vertex AI Model Garden y el extremo de modelo claude-haiku.

Puedes registrar cualquier extremo de modelo genérico, siempre que la entrada y la salida estén en formato JSON. Según los metadatos del extremo de tu modelo, es posible que debas generar encabezados HTTP o definir URLs de solicitud.

Para obtener más información sobre los modelos genéricos registrados previamente y los modelos con compatibilidad integrada, consulta Modelos compatibles.

Modelos genéricos de Gemini

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

modelo gemini-1.5-pro

Dado que algunos modelos de gemini-pro están registrados previamente, puedes llamar directamente al ID del modelo para invocar predicciones.

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

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.

Invoca predicciones con el ID del modelo registrado previamente:

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 agrega el extremo del modelo de clasificación personalizado facebook/bart-large-mnli alojado en Hugging Face.

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.
Agrega la clave de API de OpenAI como un secreto a Secret Manager para la autenticación. Si ya creaste un secreto para cualquier otro modelo de OpenAI, puedes reutilizar el mismo secreto.
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');
```
Reemplaza lo siguiente:
- SECRET_ID: Es el ID secreto que configuraste y que se usa posteriormente cuando se registra un extremo de modelo.
- SECRET_MANAGER_SECRET_ID: Es el ID de secreto establecido en Secret Manager cuando creaste el secreto.
- PROJECT_ID: Es el ID de tu Google Cloud proyecto.
- VERSION_NUMBER: El número de versión del ID secreto.
Llama a la función de creación de modelos para registrar el extremo 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');
```
Reemplaza lo siguiente:
- MODEL_ID: Es un ID único para el extremo del modelo que definas, por ejemplo, custom-classification-model. Se hace referencia a este ID de modelo para los metadatos que el extremo del modelo necesita para generar incorporaciones o invocar predicciones.
- REQUEST_URL: Es el extremo específico del modelo cuando se agregan incorporaciones de texto personalizadas y extremos de modelos genéricos, por ejemplo, https://api-inference.huggingface.co/models/facebook/bart-large-mnli.
- MODEL_QUALIFIED_NAME: Es el nombre completamente calificado de la versión del extremo del modelo, por ejemplo, facebook/bart-large-mnli.
- SECRET_ID: Es el ID secreto que usaste antes en el procedimiento google_ml.create_sm_secret().

Modelo genérico de Anthropic

En el siguiente ejemplo, se agrega el extremo del modelo claude-3-opus-20240229. La administración de extremos de modelos proporciona la función de encabezado necesaria para registrar modelos de Anthropic.

Conéctate a tu base de datos con psql.
Crea y habilita la extensión google_ml_integration.
Secret Manager
1. Agrega el token portador como un 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');
  Reemplaza lo siguiente:
  - SECRET_ID: Es el ID secreto que configuraste y que se usa posteriormente cuando se registra un extremo de modelo.
  - SECRET_MANAGER_SECRET_ID: Es el ID de secreto establecido en Secret Manager cuando creaste el secreto.
  - PROJECT_ID: Es el ID de tu Google Cloud proyecto.
  - VERSION_NUMBER: El número de versión del ID secreto.
3. Llama a la función de creación de modelos para registrar el extremo 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');
  Reemplaza lo siguiente:
  - MODEL_ID: Es un ID único para el extremo del modelo que definas, por ejemplo, anthropic-opus. Se hace referencia a este ID de modelo para los metadatos que el extremo del modelo necesita para generar incorporaciones o invocar predicciones.
  - REQUEST_URL: Es el extremo específico del modelo cuando se agregan incorporaciones de texto personalizadas y extremos de modelos genéricos, por ejemplo, https://api.anthropic.com/v1/messages.
Encabezado de la autenticación
1. Usa la función de generación de encabezados predeterminados 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; $$;
  Reemplaza lo siguiente:
  - ANTHROPIC_API_KEY: La clave de API de Anthropomorphic.
  - ANTHROPIC_VERSION (opcional): Es la versión específica del modelo que deseas usar, por ejemplo, 2023-06-01.
2. Llama a la función de creación de modelos para registrar el extremo 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');
  Reemplaza lo siguiente:
  - MODEL_ID: Es un ID único para el extremo del modelo que definas, por ejemplo, anthropic-opus. Se hace referencia a este ID de modelo para los metadatos que el extremo del modelo necesita para generar incorporaciones o invocar predicciones.
  - REQUEST_URL: Es el extremo específico del modelo cuando se agregan incorporaciones de texto personalizadas y extremos de modelos genéricos, por ejemplo, https://api.anthropic.com/v1/messages.

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