Utiliser une base de données Weaviate avec LlamaIndex sur Vertex AI pour le RAG

Cette page explique comment connecter votre corpus LlamaIndex sur Vertex AI pour le RAG à votre base de données Weaviate.

Vous pouvez utiliser votre instance de base de données Weaviate, qui est une base de données Open Source, avec LlamaIndex sur Vertex AI pour le RAG afin d'indexer et d'effectuer une recherche de similarités basée sur les vecteurs. Une recherche de similarité permet de trouver des morceaux de texte similaires au texte recherché, ce qui nécessite l'utilisation d'un modèle d'embedding. Le modèle d'embedding produit des données vectorielles pour chaque élément de texte comparé. La recherche de similarités permet de récupérer les contextes sémantiques pour l'ancrage afin de renvoyer les contenus les plus pertinents de votre LLM.

Avec LlamaIndex sur Vertex AI pour le RAG, vous pouvez continuer à utiliser votre instance de base de données vectorielle entièrement gérée, pour laquelle vous êtes responsable du provisionnement. LlamaIndex sur Vertex AI pour la RAG utilise la base de données vectorielle pour le stockage, la gestion des index et la recherche.

Remarques

Suivez les étapes ci-dessous avant d'utiliser la base de données Weaviate :

  1. Vous devez créer, configurer et déployer votre instance et votre collection de base de données Weaviate. Suivez les instructions de la section Créer votre collection Weaviate pour configurer une collection basée sur votre schéma.
  2. Vous devez fournir une clé API Weaviate, qui permet à LlamaIndex sur Vertex AI pour le RAG d'interagir avec la base de données Weaviate. LlamaIndex sur Vertex AI pour le RAG est compatible avec les processus d'authentification et d'autorisation AuthN et AuthZ basés sur les clés API, qui se connectent à votre base de données Weaviate et permettent une connexion HTTPS.
  3. LlamaIndex sur Vertex AI pour le RAG ne stocke pas et ne gère pas votre clé API Weaviate. La procédure à suivre est la suivante :
    1. Stockez votre clé dans Google Cloud Secret Manager.
    2. Accordez au compte de service de votre projet les autorisations nécessaires pour accéder à votre secret.
    3. Fournissez à LlamaIndex sur Vertex AI pour le RAG un accès au nom de ressource de votre secret.
    4. Lorsque vous interagissez avec votre base de données Weaviate, LlamaIndex sur Vertex AI pour le RAG accède à votre ressource de secret à l'aide de votre compte de service.
  4. Le corpus LlamaIndex sur Vertex AI pour le RAG et la collection Weaviate présentent un mappage de type "un à un". Les fichiers RAG sont stockés dans une collection de base de données Weaviate. Lorsqu'un appel est effectué vers l'API CreateRagCorpus ou l'API UpdateRagCorpus, le corpus RAG est associé à la collection de base de données.
  5. En plus des recherches sémantiques denses basées sur des embeddings, la recherche hybride est également prise en charge avec LlamaIndex sur Vertex AI pour le RAG via une base de données Weaviate. Vous pouvez également ajuster la pondération entre les similarités de vecteurs denses et creux dans une recherche hybride.

Provisionner la base de données Weaviate

Avant d'utiliser la base de données Weaviate avec LlamaIndex sur Vertex AI pour le RAG, vous devez effectuer les opérations suivantes :

  1. Configurer et déployer votre instance de base de données Weaviate.
  2. Préparer le point de terminaison HTTPS.
  3. Créer votre collection Weaviate.
  4. Utiliser votre clé API pour provisionner Weaviate à l'aide de AuthN et AuthZ.
  5. Provisionner votre compte de service LlamaIndex sur Vertex AI pour le RAG.

Configurer et déployer votre instance de base de données Weaviate

Vous devez suivre le guide de démarrage rapide du guide officiel de Weaviate. Toutefois, vous pouvez utiliser le guide Google Cloud Marketplace, qui est facultatif.

Vous pouvez configurer votre instance Weaviate n'importe où, à condition que le point de terminaison Weaviate soit accessible pour configurer et déployer dans votre projet. Vous pouvez ensuite gérer entièrement votre instance de base de données Weaviate.

Étant donné que LlamaIndex sur Vertex AI pour le RAG n'est impliqué à aucun stade du cycle de vie de votre instance de base de données Weaviate, il vous incombe d'accorder des autorisations à LlamaIndex sur Vertex AI pour le RAG afin qu'il puisse stocker et rechercher des données dans votre base de données Weaviate. Il est également de votre responsabilité de vous assurer que les données de votre base de données peuvent être utilisées par LlamaIndex sur Vertex AI pour le RAG. Par exemple, si vous modifiez vos données, LlamaIndex sur Vertex AI pour le RAG n'est pas responsable des comportements inattendus en raison de ces modifications.

Préparer le point de terminaison HTTPS

Lors du provisionnement de Weaviate, veillez à créer un point de terminaison HTTPS. Bien que les connexions HTTP soient compatibles, il est préférable que le trafic de LlamaIndex sur Vertex AI pour le RAG et de la base de données Weaviate utilise une connexion HTTPS.

Créer votre collection Weaviate

Étant donné que le corpus LlamaIndex sur Vertex AI pour le RAG et la collection Weaviate présentent un mappage de type "un à un", vous devez créer une collection dans votre base de données Weaviate avant de l'associer au corpus LlamaIndex sur Vertex AI pour le RAG. Cette association unique est effectuée lorsque vous appelez l'API CreateRagCorpus ou l'API UpdateRagCorpus.

Lorsque vous créez une collection dans Weaviate, vous devez utiliser le schéma suivant :

Nom de propriété Type de données
fileId text
corpusId text
chunkId text
chunkDataType text
chunkData text
fileOriginalUri text

Utiliser votre clé API pour provisionner Weaviate à l'aide de AuthN et AuthZ

Le provisionnement de la clé API Weaviate implique les étapes suivantes :

  1. Créer la clé API Weaviate.
  2. Configurer Weaviate à l'aide de votre clé API Weaviate.
  3. Stocker votre clé API Weaviate dans Secret Manager.

Créer la clé API

LlamaIndex sur Vertex AI pour le RAG ne peut se connecter à vos instances de base de données Weaviate qu'à l'aide de votre clé API pour l'authentification et l'autorisation. Vous devez suivre le guide officiel d'authentification de Weaviate pour configurer l'authentification basée sur une clé API dans votre instance de base de données Weaviate.

Si la création de la clé API Weaviate nécessite d'associer des informations d'identité provenant de LlamaIndex sur Vertex AI pour le RAG, vous devez créer votre premier corpus et utiliser votre compte de service LlamaIndex sur Vertex AI pour le RAG comme identité.

Stocker votre clé API dans Secret Manager

Une clé API contient des informations personnelles sensibles, qui sont soumises à des obligations légales. Si ces données sont compromises ou utilisées à mauvais escient, une personne physique peut être exposée à des risques ou à des préjudices importants. Pour minimiser les risques encourus par une personne lors de l'utilisation de LlamaIndex sur Vertex AI pour le RAG, ne stockez pas et ne gérez pas votre clé API, et évitez de partager la clé API non chiffrée.

Pour protéger les informations personnelles sensibles, procédez comme suit :

  1. Stockez votre clé API dans Secret Manager.
  2. Accordez à votre compte de service LlamaIndex sur Vertex AI pour le RAG les autorisations nécessaires pour vos secrets, et gérez le contrôle des accès au niveau de la ressource du secret.
    1. Accédez aux autorisations de votre projet.
    2. Activez l'option Inclure les attributions de rôles fournies par Google.
    3. Recherchez le compte de service, qui est au format suivant :

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

    4. Modifiez les comptes principaux du compte de service.
    5. Ajoutez le rôle Accesseur de secrets Secret Manager au compte de service.
  3. Lors de la création ou de la mise à jour du corpus RAG, transmettez le nom de la ressource de secret à LlamaIndex sur Vertex AI pour le RAG, puis stockez le nom de la ressource de secret.

Lorsque vous envoyez des requêtes API à vos instances de base de données Weaviate, LlamaIndex sur Vertex AI pour le RAG utilise chaque compte de service pour lire la clé API correspondant à vos ressources de secret dans Secret Manager à partir de vos projets.

Provisionner votre compte de service LlamaIndex sur Vertex AI pour le RAG

Lorsque vous créez la première ressource dans votre projet, LlamaIndex sur Vertex AI pour le RAG crée un compte de service dédié. Vous pouvez trouver votre compte de service sur la page IAM de votre projet. Le compte de service respecte le format suivant :

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

Par exemple, service-123456789@gcp-sa-prod-vertex-rag.iam.gserviceaccount.com.

Lors de l'intégration à la base de données Weaviate, votre compte de service est utilisé dans les scénarios suivants :

  • Vous pouvez utiliser votre compte de service pour générer votre clé API Weaviate à des fins d'authentification. Dans certains cas, la génération de la clé API ne nécessite aucune information utilisateur, ce qui signifie qu'un compte de service n'est pas nécessaire pour générer la clé API.
  • Vous pouvez lier votre compte de service à la clé API dans votre base de données Weaviate pour configurer l'authentification (AuthN) et l'autorisation (AuthZ). Toutefois, votre compte de service n'est pas nécessaire.
  • Vous pouvez stocker la clé API Secret Manager dans votre projet, et vous pouvez accorder à votre compte de service des autorisations pour accéder à ces ressources de secrets.
  • LlamaIndex sur Vertex AI pour le RAG utilise des comptes de service pour accéder à la clé API à partir du gestionnaire de secrets dans vos projets.

Configurer l'environnement de la console Google Cloud

Cliquez ici pour apprendre à configurer votre environnement

Découvrez comment configurer votre environnement en sélectionnant l'un des onglets suivants :

Python

  1. 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.

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

    Go to project selector

  3. Enable the Vertex AI API.

    Enable the API

    4.

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

    Go to project selector

  5. Enable the Vertex AI API.

    Enable the API

    6.

  6. 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.

  7. 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.

  8. Installez ou mettez à jour le SDK Vertex AI pour Python en exécutant la commande suivante :

    pip3 install --upgrade "google-cloud-aiplatform>=1.38"

Node.js

  1. 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.

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

    Go to project selector

  3. Enable the Vertex AI API.

    Enable the API

    4.

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

    Go to project selector

  5. Enable the Vertex AI API.

    Enable the API

    6.

  6. 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.

  7. 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.

  8. Installez ou mettez à jour le SDK Vertex AI pour Node.js en exécutant la commande suivante :

    npm install @google-cloud/vertexai

Java

  1. 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.

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

    Go to project selector

  3. Enable the Vertex AI API.

    Enable the API

    4.

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

    Go to project selector

  5. Enable the Vertex AI API.

    Enable the API

    6.

  6. 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.

  7. 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.

  8. Pour ajouter google-cloud-vertexai en tant que dépendance, ajoutez le code approprié pour votre environnement :

    Maven avec BOM

    Ajoutez le code HTML suivant à votre fichier 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 sans BOM

    Ajoutez le code HTML suivant à votre fichier 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

  1. 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.

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

    Go to project selector

  3. Enable the Vertex AI API.

    Enable the API

    4.

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

    Go to project selector

  5. Enable the Vertex AI API.

    Enable the API

    6.

  6. 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.

  7. 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.

  8. Examinez les packages Go de l'API Vertex AI disponibles pour déterminer le package qui répond le mieux aux besoins de votre projet :

    • Package cloud.google.com/go/vertexai (recommandé)

      vertexai est un package créé manuellement qui permet d'accéder aux fonctionnalités courantes.

      Ce package est recommandé comme point de départ pour la plupart des développeurs qui utilisent l'API Vertex AI. Pour accéder à des fonctionnalités qui ne sont pas encore couvertes par ce package, utilisez plutôt le package aiplatform généré automatiquement.

    • Package cloud.google.com/go/aiplatform

      aiplatform est un package généré automatiquement.

      Ce package est destiné aux projets nécessitant un accès aux fonctionnalités de l'API Vertex AI et à des fonctionnalités qui ne sont pas encore fournies par le package vertexai créé manuellement.

  9. Installez le package Go souhaité en fonction des besoins de votre projet en exécutant l'une des commandes suivantes :

    # 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#

  1. 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.

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

    Go to project selector

  3. Enable the Vertex AI API.

    Enable the API

    4.

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

    Go to project selector

  5. Enable the Vertex AI API.

    Enable the API

    6.

  6. 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.

  7. 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

  1. 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.

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

    Go to project selector

  3. Enable the Vertex AI API.

    Enable the API

    4.

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

    Go to project selector

  5. Enable the Vertex AI API.

    Enable the API

    6.

  6. 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.

  7. Configurez des variables d'environnement en saisissant les informations suivantes. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud. 
    MODEL_ID="gemini-1.5-flash-002"
PROJECT_ID="PROJECT_ID"
  8. Provisionnez le point de terminaison : 
    gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJECT_ID}

  9. Facultatif : Si vous utilisez Cloud Shell et que vous êtes invité à l'autoriser, cliquez sur Autoriser.

Préparer votre corpus RAG Vertex AI

Pour accéder aux données de votre base de données Weaviate, LlamaIndex sur Vertex AI pour le RAG doit avoir accès à un corpus RAG. Cette section décrit la procédure à suivre pour créer un seul corpus RAG et des corpus RAG supplémentaires.

Utiliser les API CreateRagCorpus et UpdateRagCorpus

Vous devez spécifier les champs suivants lorsque vous appelez les API CreateRagCorpus et UpdateRagCorpus :

  • vector_db.weaviate : la configuration de la base de données vectorielle est choisie après l'appel à l'API CreateRagCorpus. La configuration de la base de données vectorielle contient tous les champs de configuration. Si ce champ n'est pas défini, vector_db.rag_managed_db est défini par défaut.
  • weaviate.http_endpoint : le point de terminaison Weaviate HTTPS ou HTTP est créé lors du provisionnement de l'instance de base de données Weaviate.
  • weaviate.collection_name : nom de la collection créée lors du provisionnement de l'instance Weaviate. Le nom doit commencer par une lettre majuscule.
  • api_auth.api_key_config : la configuration indique qu'une clé API doit être utilisée pour autoriser l'accès à la base de données vectorielle.
  • api_key_config.api_key_secret_version : nom de la ressource de secret stocké dans Secret Manager, qui contient votre clé API Weaviate.

Vous pouvez créer et associer votre corpus RAG à la collection Weaviate dans votre instance de base de données. Toutefois, vous aurez peut-être besoin du compte de service pour générer votre clé API et configurer votre instance de base de données Weaviate. Lorsque vous créez votre premier corpus RAG, le compte de service est généré. Une fois que vous avez créé votre premier corpus RAG, il se peut que l'association entre la base de données Weaviate et la clé API ne soit pas prête à être utilisée dans la création d'un autre corpus RAG.

Dans le cas où votre base de données et votre clé ne seraient pas prêtes à être associées à votre corpus RAG, procédez comme suit sur votre corpus RAG :

  1. Définissez le champ weaviate dans rag_vector_db_config.

    • Vous ne pouvez pas modifier la base de données vectorielle associée.
    • Laissez les champs http_endpoint et collection_name vides. Les deux champs peuvent être mis à jour ultérieurement.

  2. Si votre clé API n'est pas stockée dans Secret Manager, vous pouvez laisser le champ api_auth vide. Lorsque vous appelez l'API UpdateRagCorpus, vous pouvez mettre à jour le champ api_auth. Weaviate nécessite de réaliser les opérations suivantes :

    1. Définissez api_key_config dans le champ api_auth.

    2. Définissez l'élément api_key_secret_version de votre clé API Weaviate dans Secret Manager. Le champ api_key_secret_version utilise le format suivant :

      projects/{project}/secrets/{secret}/versions/{version}

  3. Si vous spécifiez des champs qui ne peuvent être définis qu'une seule fois, tels que http_endpoint ou collection_name, vous ne pouvez pas les modifier, sauf si vous supprimez votre corpus RAG et le recréez. D'autres champs, tels que le champ de clé API, api_key_secret_version, peuvent être mis à jour.

  4. Lorsque vous appelez UpdateRagCorpus, vous pouvez définir le champ vector_db. vector_db doit être défini sur weaviate par votre appel d'API CreateRagCorpus. Sinon, le système choisit l'option Base de données gérée RAG, qui est la valeur par défaut. Cette option ne peut pas être modifiée lorsque vous appelez l'API UpdateRagCorpus. Lorsque vous appelez UpdateRagCorpus et que le champ vector_db est partiellement défini, vous pouvez mettre à jour les champs marqués comme modifiables (également appelés "mutables").

Ce tableau répertorie les champs modifiables et immuables WeaviateConfig utilisés dans votre code.

Nom du champ Modifiable ou Immuable
http_endpoint Immuable une fois défini
collection_name Immuable une fois défini
api_key_authentication Non immuable

Créer le premier corpus RAG

Lorsque le compte de service LlamaIndex sur Vertex AI pour le RAG n'existe pas, procédez comme suit :

  1. Créez un corpus RAG dans LlamaIndex sur Vertex AI pour le RAG avec une configuration Weaviate vide, ce qui lance le provisionnement de LlamaIndex sur Vertex AI pour le RAG afin de créer un compte de service.
  2. Choisissez un nom pour votre compte de service LlamaIndex sur Vertex AI pour le RAG, au format suivant :

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

    Par exemple, service-123456789@gcp-sa-prod-vertex-rag.iam.gserviceaccount.com.

  3. À l'aide de votre compte de service, accédez à votre secret stocké dans le gestionnaire de secrets de votre projet, qui contient votre clé API Weaviate.
  4. Obtenez les informations suivantes une fois le provisionnement de Weaviate terminé :
    • Votre point de terminaison HTTPS ou HTTP Weaviate.
    • Le nom de votre collection Weaviate.
  5. Appelez l'API CreateRagCorpus pour créer un corpus RAG avec une configuration Weaviate vide, puis appelez l'API UpdateRagCorpus pour mettre à jour le corpus RAG avec les informations suivantes :
    • Votre point de terminaison HTTPS ou HTTP Weaviate.
    • Le nom de votre collection Weaviate.
    • Le nom de la ressource de clé API.

Créer un autre corpus RAG

Lorsque le compte de service LlamaIndex sur Vertex AI pour le RAG existe déjà, procédez comme suit :

  1. Obtenez votre compte de service LlamaIndex sur Vertex AI pour le RAG à partir des autorisations de votre projet.
  2. Activez l'option "Inclure les attributions de rôles fournies par Google".
  3. Choisissez un nom pour votre compte de service LlamaIndex sur Vertex AI pour le RAG, au format suivant :

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

  4. À l'aide de votre compte de service, accédez à votre secret stocké dans le gestionnaire de secrets de votre projet, qui contient votre clé API Weaviate.
  5. Lors du provisionnement de Weaviate, obtenez les informations suivantes :
    • Le point de terminaison HTTPS ou HTTP de Weaviate.
    • Le nom de votre collection Weaviate.
  6. Créez un corpus RAG dans LlamaIndex sur Vertex AI pour le RAG, puis associez-le à votre collection Weaviate en effectuant l'une des opérations suivantes :
    1. Effectuez un appel d'API CreateRagCorpus pour créer un corpus RAG avec une configuration Weaviate renseignée, ce qui est l'option recommandée.
    2. Effectuez un appel d'API CreateRagCorpus pour créer un corpus RAG avec une configuration Weaviate vide, puis un appel d'API UpdateRagCorpus pour mettre à jour le corpus RAG avec les informations suivantes :
      • Le point de terminaison HTTP de la base de données Weaviate.
      • Le nom de la collection Weaviate.
      • Clé API

Exemples

Cette section présente un exemple de code qui montre comment configurer votre base de données Weaviate, Secret Manager, le corpus RAG et le fichier RAG. Un exemple de code est également fourni pour montrer comment importer des fichiers, récupérer le contexte, générer le contenu et supprimer le corpus et les fichiers RAG.

Pour utiliser le notebook de l'API RAG de Model Garden, consultez Utiliser Weaviate avec Llama 3.

Configurer votre base de données Weaviate

Cet exemple de code montre comment configurer vos données Weaviate et 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

Configurer Secret Manager

Pour configurer Secret Manager, vous devez l'activer et définir des autorisations.

Activer Secret Manager

Pour activer votre gestionnaire de secrets, procédez comme suit :

  1. Accédez à la page Secret Manager.

    Accéder à Secret Manager

  2. Cliquez sur Créer un secret.
  3. Saisissez le nom de votre secret. Les noms de secrets ne doivent contenir que des lettres en alphabet latin (A à Z), des chiffres (0 à 9), des tirets (-) et des traits de soulignement (_).
  4. La spécification des champs suivants est facultative :
    1. Pour importer le fichier avec votre secret, cliquez sur Parcourir.
    2. Consultez la règle de réplication.
    3. Si vous souhaitez gérer manuellement les emplacements de votre secret, consultez la section Gérer manuellement les emplacements de ce secret. Vous devez sélectionner au moins une région.
    4. Sélectionnez votre option de chiffrement.
    5. Si vous souhaitez définir manuellement la période de rotation, cochez la case Définir la période de rotation.
    6. Si vous souhaitez spécifier un ou plusieurs sujets de publication ou d'abonnement pour recevoir des notifications d'événement, cliquez sur Ajouter des sujets.
    7. Par défaut, le secret n'expire jamais. Si vous souhaitez définir une date d'expiration, cochez la case Définir la date d'expiration.
    8. Par défaut, les versions de secret sont détruites en cas de demande. Pour différer la destruction des versions de secret, consultez la section Définir la durée du délai de destruction.
    9. Si vous souhaitez utiliser des étiquettes pour organiser et classer vos secrets, cliquez sur + Ajouter une étiquette.
    10. Si vous souhaitez utiliser des annotations pour associer des métadonnées ne permettant pas d'identifier l'utilisateur à vos secrets, cliquez sur + Ajouter une annotation.
  5. Cliquez sur Créer un secret.

Définir des autorisations

  1. Vous devez accorder des autorisations Secret Manager à votre compte de service.

  2. Dans la section IAM et administration de la console Google Cloud, recherchez votre compte de service, puis cliquez sur l'icône en forme de crayon pour le modifier.

  3. Dans le champ Rôle, sélectionnez Accesseur de secrets Secret Manager.

Cet exemple de code montre comment configurer 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}\"}}"

Utiliser Weaviate avec Llama 3

Le notebook de l'API RAG de Model Garden montre comment utiliser le SDK Vertex AI pour Python avec un corpus Weaviate et un modèle Llama 3. Pour utiliser le notebook, procédez comme suit :

  1. Configurez votre base de données Weaviate.

  2. Configurez Secret Manager.

  3. Utilisez le notebook de l'API RAG de Model Garden.

Pour en savoir plus, consultez la section Exemples.

Créer un corpus de RAG

Cet exemple de code montre comment créer un corpus RAG et définit l'instance Weaviate comme sa base de données vectorielle.

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()

Utiliser le fichier RAG

L'API RAG gère la mise en ligne, l'importation, la création de listes et la suppression du fichier.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • RAG_CORPUS_ID : ID de la ressource RagCorpus.
  • INPUT_FILE : chemin d'accès à un fichier local.
  • FILE_DISPLAY_NAME : nom à afficher de RagFile.
  • RAG_FILE_DESCRIPTION : description du RagFile.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé INPUT_FILE, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé INPUT_FILE, puis exécutez la commande suivante :

$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
Une réponse réussie renvoie la ressource RagFile. Le dernier composant du champ RagFile.name est le rag_file_id généré par le serveur.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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)

Importer des fichiers RAG

Vous pouvez importer des fichiers et des dossiers depuis Google Drive ou Cloud Storage.

REST

Utilisez response.metadata pour afficher les échecs partiels, le temps de requête et le temps de réponse dans l'objet response du SDK.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • RAG_CORPUS_ID : ID de la ressource RagCorpus.
  • GCS_URIS : liste d'emplacements Cloud Storage. Exemple : gs://my-bucket1, gs://my-bucket2.
  • DRIVE_RESOURCE_ID : ID de la ressource Google Drive. Exemples :
    • https://drive.google.com/file/d/ABCDE
    • https://drive.google.com/corp/drive/u/0/folders/ABCDEFG
  • DRIVE_RESOURCE_TYPE : type de la ressource Google Drive. Options :
    • RESOURCE_TYPE_FILE - Fichier
    • RESOURCE_TYPE_FOLDER - Dossier
  • CHUNK_SIZE : (facultatif) Nombre de jetons que chaque fragment doit avoir.
  • CHUNK_OVERLAP : (facultatif) Nombre de chevauchements de jetons entre les fragments.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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
Une réponse réussie renvoie la ressource ImportRagFilesOperationMetadata.

L'exemple suivant montre comment importer un fichier depuis Cloud Storage. Utilisez le champ de contrôle max_embedding_requests_per_min pour limiter la fréquence à laquelle LlamaIndex sur Vertex AI pour le RAG appelle le modèle d'embedding au cours du processus d'indexation ImportRagFiles. La valeur par défaut du champ est de 1000 appels par minute.

// 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}

L'exemple suivant montre comment importer un fichier depuis Drive. Utilisez le champ de contrôle max_embedding_requests_per_min pour limiter la fréquence à laquelle LlamaIndex sur Vertex AI pour le RAG appelle le modèle d'embedding au cours du processus d'indexation ImportRagFiles. La valeur par défaut du champ est de 1000 appels par minute.

// 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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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.")

Obtenir un fichier RAG

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • RAG_CORPUS_ID : ID de la ressource RagCorpus.
  • RAG_FILE_ID : ID de la ressource RagFile.

Méthode HTTP et URL : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

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

PowerShell

Exécutez la commande suivante :

$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
Une réponse réussie renvoie la ressource RagFile.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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)

Lister les fichiers RAG

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • RAG_CORPUS_ID : ID de la ressource RagCorpus.
  • PAGE_SIZE : taille de page de la liste standard. Vous pouvez ajuster le nombre de RagFiles à renvoyer par page en mettant à jour le paramètre page_size.
  • PAGE_TOKEN : jeton de page de la liste standard. Généralement obtenu à l'aide de ListRagFilesResponse.next_page_token de l'appel VertexRagDataService.ListRagFiles précédent.

Méthode HTTP et 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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

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

Exécutez la commande suivante :

$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
Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une liste de RagFiles sous le RAG_CORPUS_ID donné.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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)

Supprimer un fichier RAG

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • RAG_CORPUS_ID : ID de la ressource RagCorpus.
  • RAG_FILE_ID : ID de la ressource RagFile. Format : projects/{project}/locations/{location}/ragCorpora/{rag_corpus}/ragFiles/{rag_file_id}.

Méthode HTTP et URL : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

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

PowerShell

Exécutez la commande suivante :

$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
Une réponse réussie renvoie la ressource DeleteOperationMetadata.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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.")

Récupérer le contexte

Lorsqu'un utilisateur pose une question ou fournit une requête, le composant de récupération du RAG effectue une recherche dans sa base de connaissances afin de trouver des informations pertinentes pour la requête.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION : région dans laquelle traiter la requête.
  • PROJECT_ID : l'ID de votre projet.
  • RAG_CORPUS_RESOURCE : nom de la ressource RagCorpus. Format : projects/{project}/locations/{location}/ragCorpora/{rag_corpus}.
  • VECTOR_DISTANCE_THRESHOLD : seuls les contextes dont la distance vectorielle est inférieure au seuil sont renvoyés.
  • TEXT : texte de requête permettant d'obtenir des contextes pertinents.
  • SIMILARITY_TOP_K : nombre de contextes principaux à récupérer.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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
Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une liste des RagFiles associés.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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)

Générer du contenu

Une prédiction contrôle la méthode LLM qui génère le contenu.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : l'ID de votre projet.
  • LOCATION : région dans laquelle traiter la requête.
  • MODEL_ID : modèle LLM pour la génération de contenu. Exemple : gemini-1.5-pro-002
  • GENERATION_METHOD : méthode LLM pour la génération de contenu. Options : generateContent, streamGenerateContent
  • INPUT_PROMPT : texte envoyé au LLM pour la génération de contenu. Essayez d'utiliser une requête pertinente pour les fichiers rag importés.
  • RAG_CORPUS_RESOURCE : nom de la ressource RagCorpus. Format : projects/{project}/locations/{location}/ragCorpora/{rag_corpus}.
  • SIMILARITY_TOP_K : (facultatif) nombre de contextes principaux à récupérer.
  • VECTOR_DISTANCE_THRESHOLD : (facultatif) les contextes dont la distance vectorielle est inférieure au seuil sont renvoyés.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

{
 "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
   }
  }
 }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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
Une réponse réussie renvoie le contenu généré avec des citations.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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-001", tools=[rag_retrieval_tool]
)
response = rag_model.generate_content("Why is the sky blue?")
print(response.text)

La recherche hybride est compatible avec la base de données Weaviate, qui combine les recherches sémantiques et par mots clés pour améliorer la pertinence des résultats de recherche. Lors de la récupération des résultats de recherche, une combinaison de scores de similarité issus de la sémantique (un vecteur dense) et de la correspondance de mots clés (un vecteur creux) produit les résultats classés finaux.

Recherche hybride à l'aide de l'API de récupération LlamaIndex sur Vertex AI pour le RAG

Voici un exemple d'activation d'une recherche hybride à l'aide de l'API de récupération LlamaIndex sur Vertex AI pour le RAG.

REST

Les variables suivantes sont utilisées dans l'exemple de code :

  • PROJECT_ID : ID de votre projet Google Cloud.
  • RAG_CORPUS_RESOURCE : nom complet de la ressource de votre corpus RAG au format projects/*/locations/us-central1/ragCorpora/*.
  • DISTANCE_THRESHOLD : seuil défini pour une distance de recherche vectorielle dans la plage [0, 1.0]. La valeur par défaut est fixée à 0.3.
  • ALPHA : la valeur alpha contrôle la pondération entre les résultats de recherche sémantiques et de mots clés. La plage est [0, 1], où 0 est une recherche vectorielle creuse et 1 une recherche vectorielle dense. La valeur par défaut est 0.5, qui équilibre les recherches vectorielles creuses et denses.
  • RETRIEVAL_QUERY : votre requête de récupération.
  • TOP_K : nombre de résultats "top-k" à récupérer.

Cet exemple montre comment appeler la méthode HTTP dans une URL.

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

Cet exemple de code montre comment utiliser le corps JSON de la requête.

  {
      "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)

Utiliser la recherche hybride et LlamaIndex sur Vertex AI pour le RAG pour la génération de réponses ancrées

Voici un exemple d'utilisation de la recherche hybride et de LlamaIndex sur Vertex AI pour le RAG pour la génération de réponses ancrées.

REST

Les variables suivantes sont utilisées dans l'exemple de code :

  • PROJECT_ID : ID de votre projet Google Cloud.
  • RAG_CORPUS_RESOURCE : nom complet de la ressource de votre corpus RAG au format projects/*/locations/us-central1/ragCorpora/*.
  • DISTANCE_THRESHOLD : seuil défini pour une distance de recherche vectorielle dans la plage [0, 1.0]. La valeur par défaut est fixée à 0.3.
  • ALPHA : la valeur alpha contrôle la pondération entre les résultats de recherche sémantiques et de mots clés. La plage est [0, 1], où 0 est une recherche vectorielle creuse et 1 une recherche vectorielle dense. La valeur par défaut est 0.5, qui équilibre les recherches vectorielles creuses et denses.
  • INPUT_PROMPT : votre requête d'entrée.
  • TOP_K : nombre de résultats "top-k" à récupérer.

Cet exemple montre comment appeler la méthode HTTP dans une URL.

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

Cet exemple de code montre comment utiliser le corps JSON de la requête.

    {
      "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)

Étape suivante