Cómo usar una base de datos de Weaviate con LlamaIndex en Vertex AI para RAG

En esta página, se muestra cómo conectar tu corpus de LlamaIndex en Vertex AI para RAG a tu base de datos de Weaviate.

Puedes usar tu instancia de la base de datos de Weaviate, que es una base de datos de código abierto, con LlamaIndex en Vertex AI para RAG para indexar y realizar una búsqueda de similitud basada en vectores. Una búsqueda de similitud es una forma de encontrar fragmentos de texto que sean similares al texto que buscas, lo que requiere el uso de un modelo de embedding. El modelo de embedding produce datos de vectores para cada fragmento de texto que se compara. La búsqueda de similitud se usa para recuperar contextos semánticos para la fundamentación y mostrar el contenido más preciso de tu LLM.

Con LlamaIndex en Vertex AI para RAG, puedes seguir usando tu instancia de base de datos de vectores completamente administrada, de la que eres responsable de aprovisionar. LlamaIndex en Vertex AI para RAG usa la base de datos de vectores para el almacenamiento, la administración de índices y la búsqueda.

Consideraciones

Ten en cuenta los siguientes pasos antes de usar la base de datos de Weaviate:

Debes crear, configurar y, luego, implementar la instancia y la colección de la base de datos de Weaviate. Sigue las instrucciones en Crea tu colección de Weaviate para configurar una colección según tu esquema.
Debes proporcionar una clave de API de Weaviate, que permite que LlamaIndex en Vertex AI para RAG interactúe con la base de datos de Weaviate. LlamaIndex en Vertex AI para RAG admite AuthN y AuthZ basados en claves de API, que se conectan a tu base de datos de Weaviate y admiten una conexión HTTPS.
LlamaIndex en Vertex AI para RAG no almacena ni administra tu clave de API de Weaviate. En su lugar, debes hacer lo siguiente:
1. Almacena tu clave en Secret Manager de Google Cloud.
2. Otorga permisos a la cuenta de servicio de tu proyecto para acceder a tu secreto.
3. Proporciona a LlamaIndex en Vertex AI para RAG acceso al nombre del recurso de tu secreto.
4. Cuando interactúas con tu base de datos de Weaviate, LlamaIndex en Vertex AI para RAG accede a tu recurso de secreto con tu cuenta de servicio.
El corpus de LlamaIndex en Vertex AI para RAG y la colección de Weaviate tienen una asignación de uno a uno. Los archivos RAG se almacenan en una colección de bases de datos de Weaviate. Cuando se realiza una llamada a la API de CreateRagCorpus o a la API de UpdateRagCorpus, el corpus de RAG se asocia a la colección de la base de datos.
Además de las búsquedas semánticas densas basadas en embeddings, la búsqueda híbrida también es compatible con LlamaIndex en Vertex AI para RAG a través de una base de datos de Weaviate. También puedes ajustar el peso entre la similitud de vectores densa y dispersa en una búsqueda híbrida.

Aprovisiona la base de datos de Weaviate

Antes de usar la base de datos de Weaviate con LlamaIndex en Vertex AI para RAG, debes hacer lo siguiente:

Configura y, luego, implementa tu instancia de la base de datos de Weaviate.
Prepara el extremo HTTPS.
Crea tu colección de Weaviate.
Usa tu clave de API para aprovisionar Weaviate con AuthN y AuthZ.
Aprovisiona tu cuenta de servicio de LlamaIndex en Vertex AI para RAG.

Configura y, luego, implementa tu instancia de la base de datos de Weaviate

Debes seguir la guía de inicio rápido de la guía oficial de Weaviate. Sin embargo, puedes usar la guía de Google Cloud Marketplace, que es opcional.

Puedes configurar tu instancia de Weaviate en cualquier lugar, siempre que se pueda acceder al extremo de Weaviate para configurarlo y, luego, implementarlo en tu proyecto. Luego, puedes administrar por completo tu instancia de la base de datos de Weaviate.

Dado que LlamaIndex en Vertex AI para RAG no participa en ninguna etapa del ciclo de vida de la instancia de la base de datos de Weaviate, es tu responsabilidad otorgar permisos a LlamaIndex en Vertex AI para RAG para que pueda almacenar y buscar datos en tu base de datos de Weaviate. También es tu responsabilidad asegurarte de que LlamaIndex en Vertex AI para RAG pueda usar los datos de tu base de datos. Por ejemplo, si cambias tus datos, LlamaIndex en Vertex AI para RAG no es responsable de ningún comportamiento inesperado debido a esos cambios.

Prepara el extremo HTTPS

Durante el aprovisionamiento de Weaviate, asegúrate de crear un extremo HTTPS. Aunque se admiten las conexiones HTTP, preferimos que LlamaIndex en Vertex AI para RAG y el tráfico de la base de datos de Weaviate usen una conexión HTTPS.

Crea tu colección de Weaviate

Debido a que el corpus de LlamaIndex en Vertex AI para RAG y la colección de Weaviate tienen una asignación de uno a uno, debes crear una colección en tu base de datos de Weaviate antes de asociarla con el corpus de LlamaIndex en Vertex AI para RAG. Esta asociación única se realiza cuando llamas a la API de CreateRagCorpus o a la API de UpdateRagCorpus.

Cuando crees una colección en Weaviate, debes usar el siguiente esquema:

Nombre de la propiedad	Tipo de datos
`fileId`	`text`
`corpusId`	`text`
`chunkId`	`text`
`chunkDataType`	`text`
`chunkData`	`text`
`fileOriginalUri`	`text`

Usa tu clave de API para aprovisionar Weaviate con `AuthN` y `AuthZ`

Aprovisionar la clave de API de Weaviate implica los siguientes pasos:

Crea la clave de API de Weaviate.
Configura Weaviate con tu clave de API de Weaviate.
Almacena tu clave de API de Weaviate en Secret Manager.

Crea la clave de API

LlamaIndex en Vertex AI para RAG solo puede conectarse a tus instancias de la base de datos de Weaviate con tu clave de API para la autenticación y autorización. Debes seguir la guía oficial de autenticación de Weaviate para configurar la autenticación basada en claves de API en tu instancia de la base de datos de Weaviate.

Si la creación de la clave de API de Weaviate requiere información de identidad para asociarse con la que proviene de LlamaIndex en Vertex AI para RAG, debes crear tu primer corpus y usar tu cuenta de servicio de LlamaIndex en Vertex AI para RAG como identidad.

Almacena tu clave de API en Secret Manager

Una clave de API contiene información de identificación personal sensible (IIPS), que está sujeta a requisitos legales. Si los datos de la SPII se ven comprometidos o se usan de forma inadecuada, una persona podría sufrir un riesgo o daño importante. Para minimizar los riesgos para una persona mientras usa LlamaIndex en Vertex AI para RAG, no almacene ni administre su clave de API, y evite compartir la clave de API sin encriptar.

Para proteger los SPII, haz lo siguiente:

Almacena tu clave de API en Secret Manager.
Otorga a tu cuenta de servicio de LlamaIndex en Vertex AI para RAG los permisos a tus secretos y administra el control de acceso a nivel del recurso secreto.
1. Navega a los permisos de tu proyecto.
2. Habilita la opción Incluir asignaciones de roles proporcionadas por Google.
3. Busca la cuenta de servicio, que tiene el formato
  service-{project number}@gcp-sa-{env-}vertex-rag.iam.gserviceaccount.com
4. Edita los principales de la cuenta de servicio.
5. Agrega el rol de Descriptor de acceso a secretos de Secret Manager a la cuenta de servicio.
Durante la creación o actualización del corpus de RAG, pasa el nombre del recurso secreto a LlamaIndex en Vertex AI para RAG y almacénalo.

Cuando realizas solicitudes a la API a tus instancias de la base de datos de Weaviate, LlamaIndex en Vertex AI para RAG usa cada cuenta de servicio para leer la clave de API que corresponde a tus recursos secretos en Secret Manager desde tus proyectos.

Aprovisiona tu cuenta de servicio de LlamaIndex en Vertex AI para RAG

Cuando creas el primer recurso de tu proyecto, LlamaIndex en Vertex AI para RAG crea una cuenta de servicio dedicada. Puedes encontrar tu cuenta de servicio en la página de IAM de tu proyecto. La cuenta de servicio sigue este formato:

service-{project number}@gcp-sa-{env-}vertex-rag.iam.gserviceaccount.com

Por ejemplo, service-123456789@gcp-sa-prod-vertex-rag.iam.gserviceaccount.com.

Cuando se realiza la integración con la base de datos de Weaviate, se usa tu cuenta de servicio en las siguientes situaciones:

Puedes usar tu cuenta de servicio para generar tu clave de API de Weaviate para la autenticación. En algunos casos, generar la clave de API no requiere información del usuario, lo que significa que no se requiere una cuenta de servicio cuando se genera la clave de API.
Puedes vincular tu cuenta de servicio con la clave de API en tu base de datos de Weaviate para configurar la autenticación (AuthN) y la autorización (AuthZ). Sin embargo, no es obligatoria.
Puedes almacenar el Secret Manager de la clave de API en tu proyecto y otorgarle permisos a tu cuenta de servicio para estos recursos secretos.
LlamaIndex en Vertex AI para RAG usa cuentas de servicio para acceder a la clave de API desde el Secret Manager en tus proyectos.

Configura tu entorno de la consola de Google Cloud

Haz clic para aprender a configurar tu entorno

Selecciona una de las siguientes pestañas para aprender a configurar tu entorno:

Python

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Nota: Si estás familiarizado con la API de Gemini en Google AI Studio, ten en cuenta que la API de Gemini para Vertex AI usa Identity and Access Management en lugar de claves de API para administrar el acceso.
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.
Instala o actualiza el SDK de Vertex AI para Python mediante la ejecución del siguiente comando:
```
pip3 install --upgrade "google-cloud-aiplatform>=1.38"
    
```

Node.js

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Nota: Si estás familiarizado con la API de Gemini en Google AI Studio, ten en cuenta que la API de Gemini para Vertex AI usa Identity and Access Management en lugar de claves de API para administrar el acceso.
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.
Instala o actualiza el SDK de Vertex AI para Node.js mediante la ejecución del siguiente comando:
```
npm install @google-cloud/vertexai
    
```

Java

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Nota: Si estás familiarizado con la API de Gemini en Google AI Studio, ten en cuenta que la API de Gemini para Vertex AI usa Identity and Access Management en lugar de claves de API para administrar el acceso.
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.

Para agregar google-cloud-vertexai como dependencia, agrega el código apropiado para tu entorno:

Maven con BOM

Agrega el siguiente HTML a tu pom.xml:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>26.32.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-vertexai</artifactId>
  </dependency>
</dependencies>

Maven sin BOM

Agrega el siguiente HTML a tu pom.xml:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-vertexai</artifactId>
  <version>0.4.0</version>
</dependency>

Gradle without BOM

Add the following to your build.gradle

implementation 'com.google.cloud:google-cloud-vertexai:0.4.0'

Go

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Nota: Si estás familiarizado con la API de Gemini en Google AI Studio, ten en cuenta que la API de Gemini para Vertex AI usa Identity and Access Management en lugar de claves de API para administrar el acceso.
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.
Revisa los paquetes disponibles de Go de la API de Vertex AI para determinar qué paquete se adapta mejor a las necesidades de tu proyecto:
- Paquete cloud.google.com/go/vertexai (recomendado)
  
  vertexai es un paquete creado por personas que proporciona acceso a capacidades y funciones comunes.
  
  Se recomienda este paquete como punto de partida para la mayoría de los desarrolladores que compilan con la API de Vertex AI. Para acceder a las capacidades y funciones que aún no se incluyen en este paquete, usa el aiplatform generado de forma automática.
- Paquete cloud.google.com/go/aiplatform
  
  aiplatform es un paquete generado de forma automática.
  
  Este paquete está diseñado para proyectos que requieren acceso a capacidades y funciones de la API de Vertex AI que aún no proporciona el paquete vertexai creado por personas.

Instala el paquete de Go deseado según las necesidades de tu proyecto a través de la ejecución de uno de los siguientes comandos:

# Human authored package. Recommended for most developers.
go get cloud.google.com/go/vertexai
    

# Auto-generated package.
go get cloud.google.com/go/aiplatform

C#

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Nota: Si estás familiarizado con la API de Gemini en Google AI Studio, ten en cuenta que la API de Gemini para Vertex AI usa Identity and Access Management en lugar de claves de API para administrar el acceso.
If you're using a local shell, then create local authentication credentials for your user account:
```
gcloud auth application-default login
```
You don't need to do this if you're using Cloud Shell.

REST

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Enable the Vertex AI API.

Enable the API

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Nota: Si estás familiarizado con la API de Gemini en Google AI Studio, ten en cuenta que la API de Gemini para Vertex AI usa Identity and Access Management en lugar de claves de API para administrar el acceso.
Ingresa lo siguiente para configurar las variables de entorno. Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.
```
MODEL_ID="gemini-1.5-flash-002"
PROJECT_ID="PROJECT_ID"
    
```

Aprovisiona el extremo:

gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJECT_ID}

Opcional: Si usas Cloud Shell y se te solicita que autorices a Cloud Shell, haz clic en Autorizar.

Prepara tu corpus de RAG de Vertex AI

Para acceder a los datos de tu base de datos de Weaviate, LlamaIndex en Vertex AI para RAG debe tener acceso a un corpus de RAG. En esta sección, se proporcionan los pasos para crear un solo corpus RAG y corpus RAG adicionales.

Usa las APIs de `CreateRagCorpus` y `UpdateRagCorpus`

Debes especificar los siguientes campos cuando llames a las APIs de CreateRagCorpus y UpdateRagCorpus:

vector_db.weaviate: La configuración de la base de datos de vectores se elige después de que llames a la API de CreateRagCorpus. La configuración de la base de datos de vectores contiene todos los campos de configuración. Si no se establece este campo, vector_db.rag_managed_db se establece de forma predeterminada.
weaviate.http_endpoint: El extremo HTTPS o HTTP de Weaviate se crea durante el aprovisionamiento de la instancia de la base de datos de Weaviate.
weaviate.collection_name: Es el nombre de la colección que se crea durante el aprovisionamiento de la instancia de Weaviate. El nombre debe comenzar con una letra mayúscula.
api_auth.api_key_config: La configuración especifica que se debe usar una clave de API para autorizar tu acceso a la base de datos de vectores.
api_key_config.api_key_secret_version: Es el nombre del recurso del secreto que se almacena en Secret Manager, que contiene tu clave de API de Weaviate.

Puedes crear y asociar tu corpus de RAG a la colección de Weaviate en tu instancia de base de datos. Sin embargo, es posible que necesites la cuenta de servicio para generar tu clave de API y configurar tu instancia de la base de datos de Weaviate. Cuando creas tu primer corpus de RAG, se genera la cuenta de servicio. Después de crear tu primer corpus de RAG, es posible que la asociación entre la base de datos de Weaviate y la clave de API no esté lista para usarse en la creación de otro corpus de RAG.

En caso de que tu base de datos y clave no estén listas para asociarse a tu corpus de RAG, haz lo siguiente:

Configura el campo weaviate en rag_vector_db_config.
- No puedes cambiar la base de datos de vectores asociada.
- Deja los campos http_endpoint y collection_name vacíos. Ambos campos se pueden actualizar más adelante.
Si no tienes tu clave de API almacenada en Secret Manager, puedes dejar el campo api_auth en blanco. Cuando llames a la API de UpdateRagCorpus, podrás actualizar el campo api_auth. Weaviate requiere que se haga lo siguiente:
1. Configura api_key_config en el campo api_auth.
2. Establece el api_key_secret_version de tu clave de API de Weaviate en Secret Manager. El campo api_key_secret_version usa el siguiente formato:
  
  projects/{project}/secrets/{secret}/versions/{version}
Si especificas campos que solo se pueden establecer una vez, como http_endpoint o collection_name, no podrás cambiarlos, a menos que borres el corpus de RAG y lo vuelvas a crear. Se pueden actualizar otros campos, como el campo de clave de API, api_key_secret_version.
Cuando llames a UpdateRagCorpus, puedes configurar el campo vector_db. Tu llamada a la API de CreateRagCorpus debe establecer vector_db en weaviate. De lo contrario, el sistema elige la opción Base de datos administrada por RAG, que es la predeterminada. No se puede cambiar esta opción cuando llamas a la API de UpdateRagCorpus. Cuando llamas a UpdateRagCorpus y el campo vector_db está configurado de forma parcial, puedes actualizar los campos que están marcados como Cambiables (también conocidos como mutables).

En esta tabla, se enumeran los campos WeaviateConfig mutables e inmutables que se usan en tu código.

Nombre del campo	Mutable o inmutable
`http_endpoint`	Inmutable una vez establecido
`collection_name`	Inmutable una vez establecido
`api_key_authentication`	Mutable

Crea el primer corpus de RAG

Cuando no exista la cuenta de servicio de LlamaIndex en Vertex AI para RAG, haz lo siguiente:

Crea un corpus de RAG en LlamaIndex en Vertex AI para RAG con una configuración vacía de Weaviate, que inicia el aprovisionamiento de LlamaIndex en Vertex AI para RAG para crear una cuenta de servicio.
Elige un nombre para tu cuenta de servicio de LlamaIndex en Vertex AI para RAG que siga este formato:

service-{project number}@gcp-sa-{env-}vertex-rag.iam.gserviceaccount.com

Por ejemplo, service-123456789@gcp-sa-prod-vertex-rag.iam.gserviceaccount.com.
Con tu cuenta de servicio, accede al secreto que se almacena en Secret Manager de tu proyecto, que contiene tu clave de API de Weaviate.
Obtén la siguiente información después de que se complete el aprovisionamiento de Weaviate:
- Tu extremo HTTPS o HTTP de Weaviate.
- Es el nombre de tu colección de Weaviate.
Llama a la API de CreateRagCorpus para crear un corpus de RAG con una configuración de Weaviate vacía y llama a la API de UpdateRagCorpus para actualizar el corpus de RAG con la siguiente información:
- Tu extremo HTTPS o HTTP de Weaviate.
- Es el nombre de tu colección de Weaviate.
- Es el nombre del recurso de la clave de API.

Crea otro corpus de RAG

Cuando exista la cuenta de servicio de LlamaIndex en Vertex AI para RAG, haz lo siguiente:

Obtén tu cuenta de servicio de LlamaIndex en Vertex AI para RAG de los permisos de tu proyecto.
Habilita la opción "Incluir asignaciones de roles proporcionadas por Google".
Elige un nombre para tu cuenta de servicio de LlamaIndex en Vertex AI para RAG que siga este formato:

service-{project number}@gcp-sa-{env-}vertex-rag.iam.gserviceaccount.com
Con tu cuenta de servicio, accede al secreto que se almacena en Secret Manager de tu proyecto, que contiene tu clave de API de Weaviate.
Durante el aprovisionamiento de Weaviate, obtén la siguiente información:
- El extremo HTTPS o HTTP de Weaviate
- Es el nombre de tu colección de Weaviate.
Crea un corpus de RAG en LlamaIndex en Vertex AI para RAG y conéctate a tu colección de Weaviate haciendo una de las siguientes acciones:
1. Realiza una llamada a la API de CreateRagCorpus para crear un corpus RAG con una configuración de Weaviate propagada, que es la opción preferida.
2. Realiza una llamada a la API de CreateRagCorpus para crear un corpus de RAG con una configuración de Weaviate vacía y realiza una llamada a la API de UpdateRagCorpus para actualizar el corpus de RAG con la siguiente información:
  - Extremo HTTP de la base de datos de Weaviate
  - Nombre de la colección de Weaviate
  - Clave de API

Ejemplos

En esta sección, se presenta un código de muestra que muestra cómo configurar tu base de datos de Weaviate, Secret Manager, el corpus de RAG y el archivo RAG. También se proporciona código de muestra para demostrar cómo importar archivos, recuperar contexto, generar contenido y borrar el corpus y los archivos de RAG.

Para usar el notebook de la API de RAG de Model Garden, consulta Cómo usar Weaviate con Llama 3.

Configura tu base de datos de Weaviate

En esta muestra de código, se muestra cómo configurar tus datos de Weaviate y Secret Manager.

# TODO(developer): Update and un-comment below lines.
# The HTTPS/HTTP Weaviate endpoint you created during provisioning.
HTTP_ENDPOINT_NAME="https://your.weaviate.endpoint.com"

# Your Weaviate API Key.
WEAVIATE_API_KEY="example-api-key"

# Select your Weaviate collection name, which roughly corresponds to a Vertex AI Knowledge Engine Corpus.
# For example, "MyCollectionName"
# Note that the first letter needs to be capitalized.
# Otherwise, Weavaite will capitalize it for you.
WEAVIATE_COLLECTION_NAME="MyCollectionName"

# Create a collection in Weaviate which includes the required schema fields shown below.
echo '{
  "class": "'${WEAVIATE_COLLECTION_NAME}'",
  "properties": [
    { "name": "fileId", "dataType": [ "string" ] },
    { "name": "corpusId", "dataType": [ "string" ] },
    { "name": "chunkId", "dataType": [ "string" ] },
    { "name": "chunkDataType", "dataType": [ "string" ] },
    { "name": "chunkData", "dataType": [ "string" ] },
    { "name": "fileOriginalUri", "dataType": [ "string" ] }
  ]
}' | curl \
    -X POST \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer "${WEAVIATE_API_KEY} \
    -d @- \
    ${HTTP_ENDPOINT_NAME}/v1/schema

Configura Secret Manager

Para configurar Secret Manager, debes habilitarlo y establecer permisos.

Habilita Secret Manager

Para habilitar tu Secret Manager, haz lo siguiente:

Ve a la página de Secret Manager.
Ir a Secret Manager
Haz clic en + Crear Secreto.
Ingresa el Nombre de tu secreto. Los nombres de los secretos solo pueden contener letras del alfabeto latino (A-Z), números (0-9), guiones (-) y guiones bajos (_).
Especificar los siguientes campos es opcional:
1. Para subir el archivo con tu secreto, haz clic en Explorar.
2. Lee la política de replicación.
3. Si deseas administrar las ubicaciones de tu secreto de forma manual, marca Administrar ubicaciones de forma manual para este secreto. Se debe seleccionar al menos una región.
4. Selecciona tu opción de encriptación.
5. Si deseas establecer el período de rotación de forma manual, marca la opción Establecer período de rotación.
6. Si deseas especificar temas de publicación o suscripción para recibir notificaciones de eventos, haz clic en Agregar temas.
7. De forma predeterminada, el Secret nunca vence. Si quieres establecer una fecha de vencimiento, marca Establecer fecha de vencimiento.
8. De forma predeterminada, las versiones del secreto se destruyen luego de solicitarlo. Para demorar la destrucción de las versiones del secreto, marca Establecer la duración de la destrucción demorada.
9. Si deseas usar etiquetas para organizar y categorizar tus secretos, haz clic en + Agregar etiqueta.
10. Si quieres usar anotaciones para adjuntar metadatos que no identifiquen tus secretos, haz clic en + Agregar anotación.
Haz clic en Crear secreto.

Configurar permisos

Debes otorgar permisos de Secret Manager a tu cuenta de servicio.
En la sección IAM y administración de la consola de Google Cloud, busca tu cuenta de servicio y haz clic en el ícono de lápiz para editarla.
En el campo Función, selecciona Descriptor de acceso a secretos de Secret Manager.

En esta muestra de código, se muestra cómo configurar tu Secret Manager.

# TODO(developer): Update and un-comment below lines.
# Select a resource name for your Secret, which will contain your API Key.
SECRET_NAME="MyWeaviateApiKeySecret"

# Create a secret in SecretManager.
curl "https://secretmanager.googleapis.com/v1/projects/${PROJECT_ID}/secrets?secretId=${SECRET_NAME}" \
    --request "POST" \
    --header "authorization: Bearer $(gcloud auth print-access-token)" \
    --header "content-type: application/json" \
    --data "{\"replication\": {\"automatic\": {}}}"

# Your Weaviate API Key.
WEAVIATE_API_KEY="example-api-key"
# Encode your WEAVIATE_API_KEY using base 64.
SECRET_DATA=$(echo ${WEAVIATE_API_KEY} | base64)

# Create a new version of your secret which uses SECRET_DATA as payload
curl.
"https://secretmanager.googleapis.com/v1/projects/${PROJECT_ID}/secrets/${SECRET_NAME}:addVersion" \
    --request "POST" \
    --header "authorization: Bearer $(gcloud auth print-access-token)" \
    --header "content-type: application/json" \
    --data "{\"payload\": {\"data\": \"${SECRET_DATA}\"}}"

Usa Weaviate con Llama 3

En el notebook de la API de RAG de Model Garden, se muestra cómo usar el SDK de Vertex AI para Python con un corpus de Weaviate y un modelo de Llama 3. Para usar el notebook, debes hacer lo siguiente:

Para obtener más ejemplos, consulta Ejemplos.

Crea un corpus RAG

En esta muestra de código, se muestra cómo crear un corpus de RAG y se establece la instancia de Weaviate como su base de datos de vectores.

REST

# TODO(developer): Update and un-comment below lines.
PROJECT_ID = "YOUR_PROJECT_ID"
# The HTTPS/HTTP Weaviate endpoint you created during provisioning.
HTTP_ENDPOINT_NAME="https://your.weaviate.endpoint.com"

# Your Weaviate collection name, which roughly corresponds to a Vertex AI Knowledge Engine Corpus.
# For example, "MyCollectionName"
# Note that the first letter needs to be capitalized.
# Otherwise, Weaviate will capitalize it for you.
WEAVIATE_COLLECTION_NAME="MyCollectionName"

# The resource name of your Weaviate API Key your Secret.
SECRET_NAME="MyWeaviateApiKeySecret"
# The Secret Manager resource name containing the API Key for your Weaviate endpoint.
# For example, projects/{project}/secrets/{secret}/versions/latest
APIKEY_SECRET_VERSION="projects/${PROJECT_ID}/secrets/${SECRET_NAME}/versions/latest"

# Select a Corpus display name.
CORPUS_DISPLAY_NAME="SpecialCorpus"

# Call CreateRagCorpus API and set all Vector DB Config parameters for Weaviate to create a new corpus associated to your selected Weaviate collection.
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/ragCorpora \
-d '{
      "display_name" : '\""${CORPUS_DISPLAY_NAME}"\"',
      "rag_vector_db_config" : {
              "weaviate": {
                    "http_endpoint": '\""${HTTP_ENDPOINT_NAME}"\"',
                    "collection_name": '\""${WEAVIATE_COLLECTION_NAME}"\"'
              },
        "api_auth" : {
                "api_key_config": {
                      "api_key_secret_version": '\""${APIKEY_SECRET_VERSION}"\"'
                }
        }
      }
  }'

# TODO(developer): Update and un-comment below lines
# Get operation_id returned in CreateRagCorpus.
OPERATION_ID="your-operation-id"

# Poll Operation status until done = true in the response.
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/operations/${OPERATION_ID}

# Call ListRagCorpora API to verify the RAG corpus is created successfully.
curl -sS -X GET \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/ragCorpora"

Python

import vertexai
from vertexai.preview import rag
from vertexai.preview.generative_models import GenerativeModel, Tool
# Set Project
PROJECT_ID = "YOUR_PROJECT_ID"  # @param {type:"string"}
vertexai.init(project=PROJECT_ID, location="us-central1")

# Configure a Google first-party embedding model
embedding_model_config = rag.EmbeddingModelConfig(
    publisher_model="publishers/google/models/text-embedding-004"
)

# Configure a third-party model or a Google fine-tuned first-party model as a Vertex Endpoint resource
# See https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/community/model_garden/model_garden_e5.ipynb for 
# deploying 3P embedding models to endpoints
ENDPOINT_ID = "your-model-endpoint-id"  # @param {type:"string"}
MODEL_ENDPOINT = "projects/{PROJECT_ID}/locations/us-central1/endpoints/{ENDPOINT_ID}"

embedding_model_config = rag.EmbeddingModelConfig(
    endpoint=MODEL_ENDPOINT,
)

# Configure a Weaviate Vector Database Instance for the corpus
WEAVIATE_HTTP_ENDPOINT = "weaviate-http-endpoint"  # @param {type:"string"}
COLLECTION_NAME = "weaviate-collection-name"  # @param {type:"string"}
API_KEY = "your-secret-manager-resource-name"  # @param {type:"string"}

vector_db = rag.Weaviate(
    weaviate_http_endpoint=WEAVIATE_HTTP_ENDPOINT,
    collection_name=COLLECTION_NAME,
    api_key=API_KEY,
)

# Name your corpus
DISPLAY_NAME = "your-corpus-name"  # @param {type:"string"}

rag_corpus = rag.create_corpus(
    display_name=DISPLAY_NAME, embedding_model_config=embedding_model_config, vector_db=vector_db
)

# Check the corpus just created
rag.list_corpora()

Usa el archivo RAG

La API de RAG controla la carga, la importación, la publicación y la eliminación de archivos.

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.
LOCATION: La región para procesar la solicitud.
RAG_CORPUS_ID: El ID del recurso RagCorpus.
INPUT_FILE: La ruta de un archivo local.
FILE_DISPLAY_NAME: es el nombre visible del RagFile.
RAG_FILE_DESCRIPTION: Es la descripción de RagFile.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/upload/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:upload

Cuerpo JSON de la solicitud:

{
 "rag_file": {
  "display_name": "FILE_DISPLAY_NAME",
  "description": "RAG_FILE_DESCRIPTION"
 }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado INPUT_FILE y ejecuta el siguiente comando:

curl -X POST \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @INPUT_FILE \
     "https://LOCATION-aiplatform.googleapis.com/upload/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:upload"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado INPUT_FILE y ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile INPUT_FILE `
    -Uri "https://LOCATION-aiplatform.googleapis.com/upload/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:upload" | Select-Object -Expand Content

Una respuesta correcta muestra el recurso RagFile. El último componente del campo RagFile.name es el rag_file_id generado por el servidor.

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de Python.


from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# corpus_name = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/{rag_corpus_id}"
# path = "path/to/local/file.txt"
# display_name = "file_display_name"
# description = "file description"

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

rag_file = rag.upload_file(
    corpus_name=corpus_name,
    path=path,
    display_name=display_name,
    description=description,
)
print(rag_file)

Importar archivos RAG

Los archivos y las carpetas se pueden importar desde Drive o Cloud Storage.

REST

Usa response.metadata para ver las fallas parciales, el tiempo de solicitud y el tiempo de respuesta en el objeto response del SDK.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.
LOCATION: La región para procesar la solicitud.
RAG_CORPUS_ID: El ID del recurso RagCorpus.
GCS_URIS: Es una lista de ubicaciones de Cloud Storage. Ejemplo: gs://my-bucket1, gs://my-bucket2.
DRIVE_RESOURCE_ID: El ID del recurso de Drive. Ejemplos:

https://drive.google.com/file/d/ABCDE
https://drive.google.com/corp/drive/u/0/folders/ABCDEFG

DRIVE_RESOURCE_TYPE: Tipo de recurso de Drive. Opciones:

RESOURCE_TYPE_FILE - Archivo
RESOURCE_TYPE_FOLDER - Carpeta

CHUNK_SIZE: Cantidad de tokens que debe tener cada fragmento (opcional).
CHUNK_OVERLAP: La cantidad de tokens que se superponen entre los fragmentos (opcional).

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/upload/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:import

Cuerpo JSON de la solicitud:

{
  "import_rag_files_config": {
    "gcs_source": {
      "uris": GCS_URIS
    },
    "google_drive_source": {
      "resource_ids": {
        "resource_id": DRIVE_RESOURCE_ID,
        "resource_type": DRIVE_RESOURCE_TYPE
      },
    }
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/upload/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:import"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/upload/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:import" | Select-Object -Expand Content

Una respuesta correcta muestra el recurso ImportRagFilesOperationMetadata.

En el siguiente ejemplo, se muestra cómo importar un archivo desde Cloud Storage. Usa el campo de control max_embedding_requests_per_min para limitar la velocidad a la que LlamaIndex en Vertex AI para RAG llama al modelo de incorporación durante el proceso de indexación ImportRagFiles. El campo tiene un valor predeterminado de 1000 llamadas por minuto.

// Cloud Storage bucket/file location.
// Such as "gs://rag-e2e-test/"
GCS_URIS=YOUR_GCS_LOCATION

// Enter the QPM rate to limit RAG's access to your embedding model
// Example: 1000
EMBEDDING_MODEL_QPM_RATE=MAX_EMBEDDING_REQUESTS_PER_MIN_LIMIT

// ImportRagFiles
// Import a single Cloud Storage file or all files in a Cloud Storage bucket.
// Input: ENDPOINT, PROJECT_ID, RAG_CORPUS_ID, GCS_URIS
// Output: ImportRagFilesOperationMetadataNumber
// Use ListRagFiles to find the server-generated rag_file_id.
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${ENDPOINT}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/ragCorpora/${RAG_CORPUS_ID}/ragFiles:import \
-d '{
  "import_rag_files_config": {
    "gcs_source": {
      "uris": '\""${GCS_URIS}"\"'
    },
    "rag_file_chunking_config": {
      "chunk_size": 512
    },
    "max_embedding_requests_per_min": '"${EMBEDDING_MODEL_QPM_RATE}"'
  }
}'

// Poll the operation status.
// The response contains the number of files imported.
OPERATION_ID=OPERATION_ID
poll_op_wait ${OPERATION_ID}

En el siguiente ejemplo, se muestra cómo importar un archivo de Drive. Usa el campo de control max_embedding_requests_per_min para limitar la velocidad a la que LlamaIndex en Vertex AI para RAG llama al modelo de incorporación durante el proceso de indexación ImportRagFiles. El campo tiene un valor predeterminado de 1000 llamadas por minuto.

// Google Drive folder location.
FOLDER_RESOURCE_ID=YOUR_GOOGLE_DRIVE_FOLDER_RESOURCE_ID

// Enter the QPM rate to limit RAG's access to your embedding model
// Example: 1000
EMBEDDING_MODEL_QPM_RATE=MAX_EMBEDDING_REQUESTS_PER_MIN_LIMIT

// ImportRagFiles
// Import all files in a Google Drive folder.
// Input: ENDPOINT, PROJECT_ID, RAG_CORPUS_ID, FOLDER_RESOURCE_ID
// Output: ImportRagFilesOperationMetadataNumber
// Use ListRagFiles to find the server-generated rag_file_id.
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${ENDPOINT}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/ragCorpora/${RAG_CORPUS_ID}/ragFiles:import \
-d '{
  "import_rag_files_config": {
    "google_drive_source": {
      "resource_ids": {
        "resource_id": '\""${FOLDER_RESOURCE_ID}"\"',
        "resource_type": "RESOURCE_TYPE_FOLDER"
      }
    },
    "max_embedding_requests_per_min": '"${EMBEDDING_MODEL_QPM_RATE}"'
  }
}'

// Poll the operation status.
// The response contains the number of files imported.
OPERATION_ID=OPERATION_ID
poll_op_wait ${OPERATION_ID}

Python


from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# corpus_name = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/{rag_corpus_id}"
# paths = ["https://drive.google.com/file/123", "gs://my_bucket/my_files_dir"]  # Supports Google Cloud Storage and Google Drive Links

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

response = rag.import_files(
    corpus_name=corpus_name,
    paths=paths,
    chunk_size=512,  # Optional
    chunk_overlap=100,  # Optional
    max_embedding_requests_per_min=900,  # Optional
)
print(f"Imported {response.imported_rag_files_count} files.")

Obtén un archivo RAG

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.
LOCATION: La región para procesar la solicitud.
RAG_CORPUS_ID: El ID del recurso RagCorpus.
RAG_FILE_ID: El ID del recurso RagFile.

Método HTTP y URL:

GET https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X GET \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID"

PowerShell

Ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID" | Select-Object -Expand Content

Una respuesta correcta muestra el recurso RagFile.

Python


from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# file_name = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/{rag_corpus_id}/ragFiles/{rag_file_id}"

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

rag_file = rag.get_file(name=file_name)
print(rag_file)

Enumera archivos Rag

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.
LOCATION: La región para procesar la solicitud.
RAG_CORPUS_ID: El ID del recurso RagCorpus.
PAGE_SIZE: El tamaño de página de lista estándar. Puedes ajustar la cantidad de RagFiles que se muestran por página si actualizas el parámetro page_size.
PAGE_TOKEN: El token de página de lista estándar. Se obtiene normalmente con ListRagFilesResponse.next_page_token de la llamada VertexRagDataService.ListRagFiles anterior.

Método HTTP y URL:

GET https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles?page_size=PAGE_SIZE&page_token=PAGE_TOKEN

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X GET \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles?page_size=PAGE_SIZE&page_token=PAGE_TOKEN"

PowerShell

Ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles?page_size=PAGE_SIZE&page_token=PAGE_TOKEN" | Select-Object -Expand Content

Deberías recibir un código de estado exitoso (2xx) junto con una lista de RagFiles en el RAG_CORPUS_ID determinado.

Python


from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# corpus_name = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/{rag_corpus_id}"

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

files = rag.list_files(corpus_name=corpus_name)
for file in files:
    print(file)

Borra un archivo RAG

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.
LOCATION: La región para procesar la solicitud.
RAG_CORPUS_ID: El ID del recurso RagCorpus.
RAG_FILE_ID: El ID del recurso RagFile. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}/ragFiles/{rag_file_id}.

Método HTTP y URL:

DELETE https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X DELETE \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID"

PowerShell

Ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID" | Select-Object -Expand Content

Una respuesta correcta muestra el recurso DeleteOperationMetadata.

Python


from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# file_name = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/{rag_corpus_id}/ragFiles/{rag_file_id}"

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

rag.delete_file(name=file_name)
print(f"File {file_name} deleted.")

Recupera el contexto

Cuando un usuario hace una pregunta o proporciona una instrucción, el componente de recuperación en RAG busca en su base de conocimiento la información relevante para la consulta.

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

LOCATION: La región para procesar la solicitud.
PROJECT_ID: El ID del proyecto.
RAG_CORPUS_RESOURCE: El nombre del recurso RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}.
VECTOR_DISTANCE_THRESHOLD: Solo se muestran los contextos con una distancia de vector menor que el umbral.
TEXT: Es el texto de la consulta para obtener contextos relevantes.
SIMILARITY_TOP_K: La cantidad de contextos principales que se recuperarán.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION:retrieveContexts

Cuerpo JSON de la solicitud:

{
 "vertex_rag_store": {
    "rag_resources": {
      "rag_corpus": "RAG_CORPUS_RESOURCE",
    },
    "vector_distance_threshold": 0.8
  },
  "query": {
   "text": "TEXT",
   "similarity_top_k": SIMILARITY_TOP_K
  }
 }

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION:retrieveContexts"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION:retrieveContexts" | Select-Object -Expand Content

Deberías recibir un código de estado exitoso (2xx) y una lista de RagFiles relacionados.

Python


from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# rag_corpus_id = "9183965540115283968" # Only one corpus is supported at this time

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

response = rag.retrieval_query(
    rag_resources=[
        rag.RagResource(
            rag_corpus=rag_corpus_id,
            # Optional: supply IDs from `rag.list_files()`.
            # rag_file_ids=["rag-file-1", "rag-file-2", ...],
        )
    ],
    text="What is RAG and why it is helpful?",
    similarity_top_k=10,  # Optional
    vector_distance_threshold=0.5,  # Optional
)
print(response)

Genera contenido

Una predicción controla el método LLM que genera contenido.

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.
LOCATION: La región para procesar la solicitud.
MODEL_ID: Es un modelo de LLM para la generación de contenido. Ejemplo: gemini-1.5-pro-002
GENERATION_METHOD: Es el método LLM para la generación de contenido. Opciones: generateContent, streamGenerateContent
INPUT_PROMPT: Es el texto enviado al LLM para la generación de contenido. Intenta usar una instrucción relevante para los archivos rag subidos.
RAG_CORPUS_RESOURCE: El nombre del recurso RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}.
SIMILARITY_TOP_K: Opcional: La cantidad de contextos principales que se recuperarán.
VECTOR_DISTANCE_THRESHOLD: Opcional: Se muestran contextos con una distancia vectorial menor que el umbral.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATION_METHOD

Cuerpo JSON de la solicitud:

{
 "contents": {
  "role": "user",
  "parts": {
    "text": "INPUT_PROMPT"
  }
 },
 "tools": {
  "retrieval": {
   "disable_attribution": false,
   "vertex_rag_store": {
    "rag_resources": {
      "rag_corpus": "RAG_CORPUS_RESOURCE",
    },
    "similarity_top_k": SIMILARITY_TOP_K,
    "vector_distance_threshold": VECTOR_DISTANCE_THRESHOLD
   }
  }
 }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATION_METHOD"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$headers = @{  }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATION_METHOD" | Select-Object -Expand Content

Una respuesta correcta muestra el contenido generado con citas.

Python


from vertexai.preview import rag
from vertexai.preview.generative_models import GenerativeModel, Tool
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# rag_corpus_id = "9183965540115283968" # Only one corpus is supported at this time

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

rag_retrieval_tool = Tool.from_retrieval(
    retrieval=rag.Retrieval(
        source=rag.VertexRagStore(
            rag_resources=[
                rag.RagResource(
                    rag_corpus=rag_corpus_id,  # Currently only 1 corpus is allowed.
                    # Optional: supply IDs from `rag.list_files()`.
                    # rag_file_ids=["rag-file-1", "rag-file-2", ...],
                )
            ],
            similarity_top_k=3,  # Optional
            vector_distance_threshold=0.5,  # Optional
        ),
    )
)

rag_model = GenerativeModel(
    model_name="gemini-1.5-flash-002", tools=[rag_retrieval_tool]
)
response = rag_model.generate_content("Why is the sky blue?")
print(response.text)

Búsqueda híbrida

La búsqueda híbrida es compatible con la base de datos de Weaviate, que combina las búsquedas semánticas y de palabras clave para mejorar la relevancia de los resultados de la búsqueda. Durante la recuperación de los resultados de la búsqueda, una combinación de puntuaciones de similitud de la semántica (un vector denso) y la concordancia de palabras clave (un vector disperso) produce los resultados finales clasificados.

Búsqueda híbrida con la API de LlamaIndex en Vertex AI para la recuperación de RAG

Este es un ejemplo de cómo habilitar una búsqueda híbrida con LlamaIndex en Vertex AI para la API de recuperación de RAG.

REST

En la muestra de código, se usan las siguientes variables:

PROJECT_ID es el ID del proyecto de Google Cloud.
RAG_CORPUS_RESOURCE: Es el nombre completo del recurso de tu corpus de RAG en el formato projects/*/locations/us-central1/ragCorpora/*.
DISTANCE_THRESHOLD: Es un umbral establecido para una distancia de búsqueda de vectores en el rango de [0, 1.0]. El valor predeterminado está configurado en 0.3.
ALPHA: El valor alfa controla el peso entre los resultados de la búsqueda semántica y de palabras clave. El rango es [0, 1], en el que 0 es una búsqueda de vectores dispersos y 1 es una búsqueda de vectores densos. El valor predeterminado es 0.5, que equilibra las búsquedas de vectores dispersos y densos.
RETRIEVAL_QUERY: Es tu consulta de recuperación.
TOP_K: Es la cantidad de resultados principales de k que se recuperarán.

En este ejemplo, se muestra cómo llamar al método HTTP en una URL.

  POST https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1:retrieveContexts

En esta muestra de código, se muestra cómo usar el cuerpo JSON de la solicitud.

  {
      "vertex_rag_store": {
        "rag_resources": {
            "rag_corpus": '\""${RAG_CORPUS_RESOURCE}"\"',
          },

        "vector_distance_threshold": ${DISTANCE_THRESHOLD}
      },
      "query": {
        "text": '\""${RETRIEVAL_QUERY}"\"',
        "similarity_top_k": ${TOP_K},
        "ranking": { "alpha" : ${ALPHA}}
      }
  }

Python

from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# rag_corpus_id = "your-rag-corpus-id" 
# Only one corpus is supported at this time

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

response = rag.retrieval_query(
    rag_resources=[
        rag.RagResource(
            rag_corpus=rag_corpus_id,
            # Optional: supply IDs from `rag.list_files()`.
            # rag_file_ids=["rag-file-1", "rag-file-2", ...],
        )
    ],
    text="What is RAG and why it is helpful?",
    similarity_top_k=10,  # Optional
    vector_distance_threshold=0.5,  # Optional
    ranking=rag.RagQuery.Ranking(
                alpha=0.5
    ),  # Optional
)
print(response)

Usa la búsqueda híbrida y LlamaIndex en Vertex AI para RAG para la generación fundamentada

Este es un ejemplo de cómo usar la búsqueda híbrida y LlamaIndex en Vertex AI para RAG para la generación fundamentada.

REST

En la muestra de código, se usan las siguientes variables:

PROJECT_ID es el ID del proyecto de Google Cloud.
RAG_CORPUS_RESOURCE: Es el nombre completo del recurso de tu corpus de RAG en el formato projects/*/locations/us-central1/ragCorpora/*.
DISTANCE_THRESHOLD: Es un umbral establecido para una distancia de búsqueda de vectores en el rango de [0, 1.0]. El valor predeterminado está configurado en 0.3.
ALPHA: El valor alfa controla el peso entre los resultados de la búsqueda semántica y de palabras clave. El rango es [0, 1], en el que 0 es una búsqueda de vectores dispersos y 1 es una búsqueda de vectores densos. El valor predeterminado es 0.5, que equilibra las búsquedas de vectores dispersos y densos.
INPUT_PROMPT: Es la instrucción de entrada.
TOP_K: Es la cantidad de resultados principales de k que se recuperarán.

En este ejemplo, se muestra cómo llamar al método HTTP en una URL.

    POST https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/publishers/google/models/gemini-pro:generateContent

En esta muestra de código, se muestra cómo usar el cuerpo JSON de la solicitud.

    {
      "contents": {
        "role": "user",
        "parts": {
          "text": '\""${INPUT_PROMPT}"\"'
        }
      },
      "tools": {
        "retrieval": {
          "vertex_rag_store": {
            "rag_resources": {
                "rag_corpus": '\""${RAG_CORPUS_RESOURCE}"\"',
              },
            "similarity_top_k": ${TOP_K},
            "vector_distance_threshold": ${DISTANCE_THRESHOLD},
            "ranking": { "alpha" : ${ALPHA}}
          }
        }
      }
    }

Python

from vertexai.preview import rag
from vertexai.preview.generative_models import GenerativeModel, Tool
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# rag_corpus_id = "your-rag-corpus-id" # Only one corpus is supported at this time

# Initialize Vertex AI API once per session
vertexai.init(project=PROJECT_ID, location="us-central1")

rag_retrieval_tool = Tool.from_retrieval(
    retrieval=rag.Retrieval(
        source=rag.VertexRagStore(
            rag_resources=[
                rag.RagResource(
                    rag_corpus=rag_corpus_id,  # Currently only 1 corpus is allowed.
                    # Optional: supply IDs from `rag.list_files()`.
                    # rag_file_ids=["rag-file-1", "rag-file-2", ...],
                )
            ],
            similarity_top_k=3,  # Optional
            vector_distance_threshold=0.5,  # Optional
            ranking=rag.RagQuery.Ranking(
                        alpha=0.5
            ),  # Optional
        ),
    )
)

rag_model = GenerativeModel(
    model_name="gemini-1.5-flash-001", tools=[rag_retrieval_tool]
)
response = rag_model.generate_content("Why is the sky blue?")
print(response.text)

¿Qué sigue?

Para obtener más información sobre la fundamentación, consulta Descripción general de la puesta a tierra.
Para obtener más información sobre LlamaIndex en Vertex AI para RAG, consulta Cómo usar LlamaIndex en Vertex AI para RAG.
Para obtener más información sobre la fundamentación y la RAG, consulta Cómo fundamentar respuestas con RAG.

Cómo usar una base de datos de Weaviate con LlamaIndex en Vertex AI para RAG

Consideraciones

Aprovisiona la base de datos de Weaviate

Configura y, luego, implementa tu instancia de la base de datos de Weaviate

Prepara el extremo HTTPS

Crea tu colección de Weaviate

Usa tu clave de API para aprovisionar Weaviate con AuthN y AuthZ

Crea la clave de API

Almacena tu clave de API en Secret Manager

Aprovisiona tu cuenta de servicio de LlamaIndex en Vertex AI para RAG

Configura tu entorno de la consola de Google Cloud

Haz clic para aprender a configurar tu entorno

Python

Node.js

Java

Maven con BOM

Maven sin BOM

Gradle without BOM

Go

C#

REST

Prepara tu corpus de RAG de Vertex AI

Usa las APIs de CreateRagCorpus y UpdateRagCorpus

Crea el primer corpus de RAG

Crea otro corpus de RAG

Ejemplos

Configura tu base de datos de Weaviate

Configura Secret Manager

Habilita Secret Manager

Configurar permisos

Usa Weaviate con Llama 3

Crea un corpus RAG

REST

Python

Usa el archivo RAG

REST

curl

PowerShell

Python

Importar archivos RAG

REST

curl

PowerShell

Python

Obtén un archivo RAG

REST

curl

PowerShell

Python

Enumera archivos Rag

REST

curl

PowerShell

Python

Borra un archivo RAG

REST

curl

PowerShell

Python

Recupera el contexto

REST

curl

PowerShell

Python

Genera contenido

REST

curl

PowerShell

Python

Búsqueda híbrida

Búsqueda híbrida con la API de LlamaIndex en Vertex AI para la recuperación de RAG

REST

Python

Usa la búsqueda híbrida y LlamaIndex en Vertex AI para RAG para la generación fundamentada

REST

Python

¿Qué sigue?

Usa tu clave de API para aprovisionar Weaviate con `AuthN` y `AuthZ`

Usa las APIs de `CreateRagCorpus` y `UpdateRagCorpus`