Utilizzare un database Weaviate con il motore RAG di Vertex AI

Questa pagina mostra come connettere il corpus RAG Engine al database Weaviate.

Puoi anche seguire le istruzioni utilizzando questo notebook Motore RAG con Weaviate.

Puoi utilizzare l'istanza del database Weaviate, che è un database open source, con RAG Engine per indicizzare ed eseguire una ricerca di somiglianza basata su vettori. Una ricerca per similarità è un modo per trovare brani di testo simili a quello che stai cercando, il che richiede l'utilizzo di un modello di incorporamento. Il modello di incorporamento produce dati vettoriali per ogni porzione di testo confrontata. La ricerca di similarità viene utilizzata per recuperare contesti semantici per il grounding per restituire i contenuti più accurati dal tuo LLM.

Con RAG Engine, puoi continuare a utilizzare l'istanza del database vettoriale completamente gestita, di cui sei responsabile del provisioning. RAG Engine utilizza il database vettoriale per l'archiviazione, la gestione degli indici e la ricerca.

Considerazioni

Prima di utilizzare il database Weaviate, considera i seguenti passaggi:

1. Devi creare, configurare ed eseguire il deployment dell'istanza e della raccolta del database Weaviate. Segui le istruzioni riportate in Crea la raccolta Weaviate per configurare una raccolta in base allo schema.
2. Devi fornire una chiave API Weaviate, che consente a RAG Engine di interagire con il database Weaviate. RAG Engine supporta AuthN e AuthZ basati su chiave API, che si connettono al tuo database Weaviate e supportano una connessione HTTPS.
3. RAG Engine non archivia e gestisce la chiave API Weaviate. Devi invece procedere nel seguente modo:
   1. Archivia la chiave in Google Cloud Secret Manager.
   2. Concedi all'account di servizio del progetto le autorizzazioni per accedere al secret.
   3. Fornisci l'accesso a RAG Engine al nome della risorsa del tuo secret.
   4. Quando interagisci con il database Weaviate, RAG Engine accede alla risorsa secret utilizzando il tuoaccount di serviziot.
4. Il corpus del motore RAG e la raccolta Weaviate hanno una mappatura uno a uno. I file RAG vengono archiviati in una raccolta di database Weaviate. Quando viene effettuata una chiamata all'API CreateRagCorpus o all'API UpdateRagCorpus, il corpus RAG viene associato alla raccolta del database.
5. Oltre alle ricerche semantiche basate su incorporamenti densi, la ricerca ibrida è supportata anche da RAG Engine tramite un database Weaviate. Puoi anche regolare la ponderazione tra la somiglianza vettoriale densa e quella sparsa in una ricerca ibrida.

Esegui il provisioning del database Weaviate

Prima di utilizzare il database Weaviate con il motore RAG, devi svolgere le seguenti operazioni:

1. Configura ed esegui il deployment dell'istanza del database Weaviate.
2. Prepara l'endpoint HTTPS.
3. Crea la raccolta Weaviate.
4. Utilizza la chiave API per eseguire il provisioning di Weaviate utilizzando AuthN e AuthZ.
5. Esegui il provisioning del account di servizio RAG Engine.

Configura ed esegui il deployment dell'istanza del database Weaviate

Devi seguire la guida rapida ufficiale di Weaviate. Tuttavia, puoi utilizzare la guida diGoogle Cloud Marketplace, che è facoltativa.

Puoi configurare l'istanza di Weaviate ovunque, purché l'endpoint Weaviate sia accessibile per la configurazione e il deployment nel tuo progetto. Puoi quindi gestire completamente l'istanza del database Weaviate.

Poiché RAG Engine non è coinvolto in nessuna fase del ciclo di vita dell'istanza del database Weaviate, è tua responsabilità concedere le autorizzazioni a RAG Engine in modo che possa archiviare e cercare dati nel tuo database Weaviate. È inoltre tua responsabilità assicurarti che i dati nel tuo database possano essere utilizzati da RAG Engine. Ad esempio, se modifichi i tuoi dati, RAG Engine non è responsabile di eventuali comportamenti imprevisti dovuti a queste modifiche.

Prepara l'endpoint HTTPS

Durante il provisioning di Weaviate, assicurati di creare un endpoint HTTPS. Sebbene le connessioni HTTP siano supportate, preferiamo che il traffico del motore RAG e del database Weaviate utilizzi una connessione HTTPS.

Crea la tua raccolta Weaviate

Poiché il corpus del motore RAG e la raccolta Weaviate hanno una mappatura uno a uno, devi creare una raccolta nel database Weaviate prima di associarla al corpus del motore RAG. Questa associazione una tantum viene creata quando chiami l'API CreateRagCorpus o l'API UpdateRagCorpus.

Quando crei una raccolta in Weaviate, devi utilizzare lo schema seguente:

Utilizza la chiave API per eseguire il provisioning di Weaviate utilizzando AuthN e AuthZ

Il provisioning della chiave API Weaviate prevede i seguenti passaggi:

1. Crea la chiave API Weaviate.
2. Configura Weaviate utilizzando la chiave API di Weaviate.
3. Archivia la chiave API Weaviate in Secret Manager.

Crea la chiave API

RAG Engine può connettersi alle istanze del database Weaviate solo utilizzando la chiave API per l'autenticazione e l'autorizzazione. Per configurare l'autenticazione basata su chiave API nell'istanza del database Weaviate, devi seguire la guida ufficiale di Weaviate all'autenticazione.

Se la creazione della chiave API Weaviate richiede informazioni sull'identità da associare che provengono dal motore RAG, devi creare il tuo primo corpus e utilizzare il tuo account di servizio del motore RAG come identità.

Archivia la chiave API in Secret Manager

Una chiave API contiene informazioni sensibili che consentono l'identificazione personale (informazioni personali sensibili), che sono soggette a requisiti legali. Se i dati SPII vengono compromessi o utilizzati in modo improprio, un privato potrebbe subire un rischio o un danno significativo. Per ridurre al minimo i rischi per una persona durante l'utilizzo di RAG Engine, non archiviare e gestire la chiave API ed evita di condividerla non criptata.

Per proteggere le informazioni sensibili di identificazione personale:

1. Archivia la chiave API in Secret Manager.
2. Concedi al tuo account di servizio RAG Engine le autorizzazioni per i tuoi secret e gestisci ilcontrollo dell'accessoo a livello di risorsa secret.
   1. Vai alle autorizzazioni del progetto.
   2. Attiva l'opzione Includi concessioni di ruoli fornite da Google.
   3. Trova il account di servizio, che ha il formato

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

   4. Modifica le entità dell'account di servizio.
   5. Aggiungi il ruolo Funzione di accesso ai secret di Secret Manager al service account.
3. Durante la creazione o l'aggiornamento del corpus RAG, passa il nome della risorsa secret a RAG Engine e memorizzalo.

Quando effettui richieste API alle tue istanze di database Weaviate, RAG Engine utilizza ogniaccount di serviziot per leggere la chiave API corrispondente alle tue risorse secret in Secret Manager dai tuoi progetti.

Esegui il provisioning del account di servizio RAG Engine

Quando crei la prima risorsa nel tuo progetto, RAG Engine crea un account di servizio dedicato. Puoi trovare il account di servizio nella pagina IAM del progetto. Il account di servizio segue questo formato:

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

Ad esempio, service-123456789@gcp-sa-vertex-rag.iam.gserviceaccount.com.

Quando esegui l'integrazione con il database Weaviate, il tuo account di servizio viene utilizzato nei seguenti scenari:

• Puoi utilizzare il account di servizio per generare la chiave API Weaviate per l'autenticazione. In alcuni casi, la generazione della chiave API non richiede informazioni sull'utente, il che significa che non è necessario unaccount di serviziot quando viene generata la chiave API.
• Puoi associare il account di servizio alla chiave API nel database Weaviate per configurare l'autenticazione (AuthN) e l'autorizzazione (AuthZ). Tuttavia, il account di servizio non è obbligatorio.
• Puoi archiviare la chiave API Secret Manager nel tuo progetto e concedere al account di servizio le autorizzazioni per queste risorse secret.
• RAG Engine utilizza i service account per accedere alla chiave API da Secret Manager nei tuoi progetti.

Configura l'ambiente della console Google Cloud

Prepara il corpus RAG

Per accedere ai dati del database Weaviate, RAG Engine deve avere accesso a un corpus RAG. Questa sezione fornisce i passaggi per creare un singolo corpus RAG e corpus RAG aggiuntivi.

Utilizzare le API CreateRagCorpus e UpdateRagCorpus

Quando chiami le API CreateRagCorpus e UpdateRagCorpus, devi specificare i seguenti campi:

• rag_vector_db_config.weaviate: dopo aver chiamato l'API CreateRagCorpus, viene scelta la configurazione del database vettoriale. La configurazione del database vettoriale contiene tutti i campi di configurazione. Se il campo rag_vector_db_config.weaviate non è impostato, rag_vector_db_config.rag_managed_db viene impostato per impostazione predefinita.
• weaviate.http_endpoint: l'endpoint Weaviate HTTP o HTTPS viene creato durante il provisioning dell'istanza del database Weaviate.
• weaviate.collection_name: il nome della raccolta creata durante il provisioning dell'istanza Weaviate. Il nome deve iniziare con una lettera maiuscola.
• api_auth.api_key_config: la configurazione specifica di utilizzare una chiave API per autorizzare l'accesso al database vettoriale.
• api_key_config.api_key_secret_version: il nome della risorsa del secret memorizzato in Secret Manager, che contiene la chiave API di Weaviate.

Puoi creare e associare il tuo corpus RAG alla raccolta Weaviate nell'istanza del database. Tuttavia, potresti aver bisogno del account di servizio per generare la chiave API e configurare l'istanza del database Weaviate. Quando crei il tuo primo corpus RAG, viene generato il account di servizio. Dopo aver creato il primo corpus RAG, l'associazione tra il database Weaviate e la chiave API potrebbe non essere pronta per l'uso nella creazione di un altro corpus RAG.

Nel caso in cui il database e la chiave non siano pronti per essere associati al tuo corpus RAG, esegui le seguenti operazioni sul corpus RAG:

1. Imposta il campo weaviate in rag_vector_db_config.

   • Non puoi modificare il database vettoriale associato.
   • Lascia vuoti i campi http_endpoint e collection_name. Entrambi i campi possono essere aggiornati in un secondo momento.

2. Se non hai memorizzato la chiave API in Secret Manager, puoi lasciare vuoto il campo api_auth. Quando chiami l'API UpdateRagCorpus, puoi aggiornare il campo api_auth. Weaviate richiede che vengano eseguite le seguenti operazioni:

   1. Imposta api_key_config nel campo api_auth.

   2. Imposta api_key_secret_version della chiave API Weaviate in Secret Manager. Il campo api_key_secret_version utilizza il seguente formato:

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

3. Se specifichi campi che possono essere impostati una sola volta, come http_endpoint o collection_name, non puoi modificarli a meno che non elimini il corpus RAG e lo crei di nuovo. Altri campi, come quello della chiave API, api_key_secret_version, possono essere aggiornati.

4. Quando chiami UpdateRagCorpus, puoi impostare il campo vector_db. vector_db deve essere impostato su weaviate dalla chiamata API CreateRagCorpus. In caso contrario, il sistema sceglie l'opzione Database gestito RAG, che è l'impostazione predefinita. Questa opzione non può essere modificata quando chiami l'API UpdateRagCorpus. Quando chiami UpdateRagCorpus e il campo vector_db è impostato parzialmente, puoi aggiornare i campi contrassegnati come Modificabile (anche denominati modificabili).

Questa tabella elenca i campi modificabili e immutabili di WeaviateConfig utilizzati nel codice.

Crea il primo corpus RAG

Quando il account di servizio RAG Engine non esiste:

1. Crea un corpus RAG nel motore RAG con una configurazione Weaviate vuota, che avvia il provisioning del motore RAG per creare unaccount di serviziot.
2. Scegli un nome per il account di servizio RAG Engine che rispetti questo formato:
   

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

   Ad esempio, service-123456789@gcp-sa-vertex-rag.iam.gserviceaccount.com.

3. Utilizza il account di servizio per accedere al secret archiviato in Secret Manager del tuo progetto, che contiene la chiave API Weaviate.
4. Una volta completato il provisioning di Weaviate, ottieni le seguenti informazioni:
   • L'endpoint HTTP o HTTPS di Weaviate.
   • Il nome della tua raccolta Weaviate.
5. Chiama l'API CreateRagCorpus per creare un corpus RAG con una configurazione Weaviate vuota e chiama l'API UpdateRagCorpus per aggiornare il corpus RAG con le seguenti informazioni:
   • L'endpoint HTTP o HTTPS di Weaviate.
   • Il nome della tua raccolta Weaviate.
   • Il nome della risorsa della chiave API.

Crea un altro corpus RAG

Quando esiste il account di servizio RAG Engine:

1. Recupera il account di servizio RAG Engine dalle autorizzazioni del progetto.
2. Attiva l'opzione "Includi concessioni di ruoli fornite da Google".
3. Scegli un nome per il account di servizio RAG Engine che rispetti questo formato:
   

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

4. Utilizza il account di servizio per accedere al secret archiviato in Secret Manager del tuo progetto, che contiene la chiave API Weaviate.
5. Durante il provisioning di Weaviate, recupera le seguenti informazioni:
   • L'endpoint HTTP o HTTPS di Weaviate.
   • Il nome della tua raccolta Weaviate.
6. Crea un corpus RAG nel motore RAG e connettiti alla raccolta Weaviate in uno dei seguenti modi:
   1. Esegui una chiamata API CreateRagCorpus per creare un corpus RAG con una configurazione Weaviate compilata, che è l'opzione preferita.
   2. Esegui una chiamata API CreateRagCorpus per creare un corpus RAG con una configurazione Weaviate vuota ed esegui una chiamata API UpdateRagCorpus per aggiornare il corpus RAG con le seguenti informazioni:
      • Endpoint HTTP del database Weaviate
      • Nome della raccolta Weaviate
      • Chiave API

Esempi

Questa sezione presenta codice campione che mostra come configurare il database Weaviate, Secret Manager, il corpus RAG e il file RAG. Viene fornito anche un codice di esempio per mostrare come importare file, recuperare il contesto, generare contenuti ed eliminare il corpus RAG e i file RAG.

Per utilizzare il blocco note dell'API Model Garden RAG, consulta Utilizzare Weaviate con Llama 3.

Configura il database Weaviate

Questo esempio di codice mostra come configurare i dati di Weaviate e Secret Manager.

# TODO(developer): Update the variables.
# 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

Configurare Secret Manager

Per configurare Secret Manager, devi abilitarlo e impostare le autorizzazioni.

Crea secret

Per abilitare Secret Manager:

# 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\": {}}}"

# Import the Secret Manager client library.
from google.cloud import secretmanager


def create_secret(
    project_id: str, secret_id: str, ttl: Optional[str] = None
) -> secretmanager.Secret:
    """
    Create a new secret with the given name. A secret is a logical wrapper
    around a collection of secret versions. Secret versions hold the actual
    secret material.

     Args:
        project_id (str): The project ID where the secret is to be created.
        secret_id (str): The ID to assign to the new secret. This ID must be unique within the project.
        ttl (Optional[str]): An optional string that specifies the secret's time-to-live in seconds with
                             format (e.g., "900s" for 15 minutes). If specified, the secret
                             versions will be automatically deleted upon reaching the end of the TTL period.

    Returns:
        secretmanager.Secret: An object representing the newly created secret, containing details like the
                              secret's name, replication settings, and optionally its TTL.

    Example:
        # Create a secret with automatic replication and no TTL
        new_secret = create_secret("my-project", "my-new-secret")

        # Create a secret with a TTL of 30 days
        new_secret_with_ttl = create_secret("my-project", "my-timed-secret", "7776000s")
    """

    # Create the Secret Manager client.
    client = secretmanager.SecretManagerServiceClient()

    # Build the resource name of the parent project.
    parent = f"projects/{project_id}"

    # Create the secret.
    response = client.create_secret(
        request={
            "parent": parent,
            "secret_id": secret_id,
            "secret": {"replication": {"automatic": {}}, "ttl": ttl},
        }
    )

    # Print the new secret name.
    print(f"Created secret: {response.name}")

Imposta autorizzazioni

Devi concedere le autorizzazioni Secret Manager al tuo account di servizio.

def iam_grant_access(
    project_id: str, secret_id: str, member: str
) -> iam_policy_pb2.SetIamPolicyRequest:
    """
    Grant the given member access to a secret.
    """

    # Import the Secret Manager client library.
    from google.cloud import secretmanager

    # Create the Secret Manager client.
    client = secretmanager.SecretManagerServiceClient()

    # Build the resource name of the secret.
    name = client.secret_path(project_id, secret_id)

    # Get the current IAM policy.
    policy = client.get_iam_policy(request={"resource": name})

    # Add the given member with access permissions.
    policy.bindings.add(role="roles/secretmanager.secretAccessor", members=[member])

    # Update the IAM Policy.
    new_policy = client.set_iam_policy(request={"resource": name, "policy": policy})

    # Print data about the secret.
    print(f"Updated IAM policy on {secret_id}")

Aggiungi versione secret

# TODO(developer): Update the variables.
# Select a resource name for your Secret, which contains your API Key.
SECRET_NAME="MyWeaviateApiKeySecret"

# 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}\"}}"

from google.cloud import secretmanager
import google_crc32c  # type: ignore


def add_secret_version(
    project_id: str, secret_id: str, payload: str
) -> secretmanager.SecretVersion:
    """
    Add a new secret version to the given secret with the provided payload.
    """

    # Create the Secret Manager client.
    client = secretmanager.SecretManagerServiceClient()

    # Build the resource name of the parent secret.
    parent = client.secret_path(project_id, secret_id)

    # Convert the string payload into a bytes. This step can be omitted if you
    # pass in bytes instead of a str for the payload argument.
    payload_bytes = payload.encode("UTF-8")

    # Calculate payload checksum. Passing a checksum in add-version request
    # is optional.
    crc32c = google_crc32c.Checksum()
    crc32c.update(payload_bytes)

    # Add the secret version.
    response = client.add_secret_version(
        request={
            "parent": parent,
            "payload": {
                "data": payload_bytes,
                "data_crc32c": int(crc32c.hexdigest(), 16),
            },
        }
    )

    # Print the new secret version name.
    print(f"Added secret version: {response.name}")

Utilizzare Weaviate con Llama 3

Il notebook dell'API RAG di Model Garden mostra come utilizzare l'SDK Vertex AI per Python con un corpus Weaviate e il modello Llama 3. Per utilizzare il notebook, devi:

1. Configura il database Weaviate.

2. Configura Secret Manager.

3. Utilizza il notebook dell'API Model Garden RAG.

Per altri esempi, consulta la sezione Esempi.

Crea un corpus RAG

Questo esempio di codice mostra come creare un corpus RAG e imposta l'istanza Weaviate come database vettoriale.

  # TODO(developer): Update the variables.
  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 the variables.
  # 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"

from vertexai.preview import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# weaviate_http_endpoint = "weaviate-http-endpoint"
# weaviate_collection_name = "weaviate-collection-name"
# weaviate_api_key_secret_manager_version = "projects/{PROJECT_ID}/secrets/{SECRET_NAME}/versions/latest"
# display_name = "test_corpus"
# description = "Corpus Description"

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

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

# Configure Vector DB
vector_db = rag.Weaviate(
    weaviate_http_endpoint=weaviate_http_endpoint,
    collection_name=weaviate_collection_name,
    api_key=weaviate_api_key_secret_manager_version,
)

corpus = rag.create_corpus(
    display_name=display_name,
    description=description,
    embedding_model_config=embedding_model_config,
    vector_db=vector_db,
)
print(corpus)
# Example response:
# RagCorpus(name='projects/1234567890/locations/us-central1/ragCorpora/1234567890',
# display_name='test_corpus', description='Corpus Description', embedding_model_config=...
# ...

Utilizzare il file RAG

L'API RAG gestisce il caricamento, l'importazione, l'elenco e l'eliminazione dei file.

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

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

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"

$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

from vertexai 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)
# RagFile(name='projects/[PROJECT_ID]/locations/us-central1/ragCorpora/1234567890/ragFiles/09876543',
#  display_name='file_display_name', description='file description')

Importare file RAG

File e cartelle possono essere importati da Drive o Cloud Storage.

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

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

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"

$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

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

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

from vertexai 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,
    transformation_config=rag.TransformationConfig(
        rag.ChunkingConfig(chunk_size=512, chunk_overlap=100)
    ),
    import_result_sink="gs://sample-existing-folder/sample_import_result_unique.ndjson",  # Optional, this has to be an existing storage bucket folder, and file name has to be unique (non-existent).
    max_embedding_requests_per_min=900,  # Optional
)
print(f"Imported {response.imported_rag_files_count} files.")
# Example response:
# Imported 2 files.

Recuperare un file RAG

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

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

$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

from vertexai 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)
# Example response:
# RagFile(name='projects/1234567890/locations/us-central1/ragCorpora/11111111111/ragFiles/22222222222',
# display_name='file_display_name', description='file description')

Elenca i file RAG

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

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"

$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

from vertexai 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.display_name)
    print(file.name)
# Example response:
# g-drive_file.txt
# projects/1234567890/locations/us-central1/ragCorpora/111111111111/ragFiles/222222222222
# g_cloud_file.txt
# projects/1234567890/locations/us-central1/ragCorpora/111111111111/ragFiles/333333333333

Eliminare un file RAG

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

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

$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

from vertexai 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.")
# Example response:
# Successfully deleted the RagFile.
# File projects/1234567890/locations/us-central1/ragCorpora/1111111111/ragFiles/2222222222 deleted.

Recuperare il contesto

Quando un utente pone una domanda o fornisce un prompt, il componente di recupero in RAG cerca nella sua knowledge base le informazioni pertinenti alla query.

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

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

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"

$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

from vertexai 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")

response = rag.retrieval_query(
    rag_resources=[
        rag.RagResource(
            rag_corpus=corpus_name,
            # Optional: supply IDs from `rag.list_files()`.
            # rag_file_ids=["rag-file-1", "rag-file-2", ...],
        )
    ],
    text="Hello World!",
    rag_retrieval_config=rag.RagRetrievalConfig(
        top_k=10,
        filter=rag.utils.resources.Filter(vector_distance_threshold=0.5),
    ),
)
print(response)
# Example response:
# contexts {
#   contexts {
#     source_uri: "gs://your-bucket-name/file.txt"
#     text: "....
#   ....

Genera contenuti

Una previsione controlla il metodo LLM che genera contenuti.

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

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

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"

$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

from vertexai import rag
from vertexai.generative_models import GenerativeModel, Tool
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")

rag_retrieval_tool = Tool.from_retrieval(
    retrieval=rag.Retrieval(
        source=rag.VertexRagStore(
            rag_resources=[
                rag.RagResource(
                    rag_corpus=corpus_name,
                    # Optional: supply IDs from `rag.list_files()`.
                    # rag_file_ids=["rag-file-1", "rag-file-2", ...],
                )
            ],
            rag_retrieval_config=rag.RagRetrievalConfig(
                top_k=10,
                filter=rag.utils.resources.Filter(vector_distance_threshold=0.5),
            ),
        ),
    )
)

rag_model = GenerativeModel(
    model_name="gemini-2.0-flash-001", tools=[rag_retrieval_tool]
)
response = rag_model.generate_content("Why is the sky blue?")
print(response.text)
# Example response:
#   The sky appears blue due to a phenomenon called Rayleigh scattering.
#   Sunlight, which contains all colors of the rainbow, is scattered
#   by the tiny particles in the Earth's atmosphere....
#   ...

Ricerca ibrida

La ricerca ibrida è supportata dal database Weaviate, che combina la ricerca semantica e quella per parole chiave per migliorare la pertinenza dei risultati di ricerca. Durante il recupero dei risultati di ricerca, una combinazione di punteggi di similarità provenienti dalla corrispondenza semantica (un vettore denso) e dalla corrispondenza delle parole chiave (un vettore sparso) produce i risultati finali classificati.

Ricerca ibrida utilizzando l'API di recupero di RAG Engine

Questo è un esempio di come abilitare una ricerca ibrida utilizzando l'API di recupero di RAG Engine.

  # TODO(developer): Update the variables.
  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 the variables.
  # 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"

from vertexai 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")

response = rag.retrieval_query(
    rag_resources=[
        rag.RagResource(
            rag_corpus=corpus_name,
            # Optional: supply IDs from `rag.list_files()`.
            # rag_file_ids=["rag-file-1", "rag-file-2", ...],
        )
    ],
    text="Hello World!",
    rag_retrieval_config=rag.RagRetrievalConfig(
        top_k=10,
        filter=rag.utils.resources.Filter(vector_distance_threshold=0.5),
    ),
)
print(response)
# Example response:
# contexts {
#   contexts {
#     source_uri: "gs://your-bucket-name/file.txt"
#     text: "....
#   ....

Utilizzare la ricerca ibrida e RAG Engine per la generazione con grounding

Questo è un esempio di come utilizzare la ricerca ibrida e il motore RAG per la generazione con grounding.

  # TODO(developer): Update the variables.
  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 the variables.
  # 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"

from vertexai import rag
from vertexai.generative_models import GenerativeModel, Tool
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")

rag_retrieval_tool = Tool.from_retrieval(
    retrieval=rag.Retrieval(
        source=rag.VertexRagStore(
            rag_resources=[
                rag.RagResource(
                    rag_corpus=corpus_name,
                    # Optional: supply IDs from `rag.list_files()`.
                    # rag_file_ids=["rag-file-1", "rag-file-2", ...],
                )
            ],
            rag_retrieval_config=rag.RagRetrievalConfig(
                top_k=10,
                filter=rag.utils.resources.Filter(vector_distance_threshold=0.5),
            ),
        ),
    )
)

rag_model = GenerativeModel(
    model_name="gemini-2.0-flash-001", tools=[rag_retrieval_tool]
)
response = rag_model.generate_content("Why is the sky blue?")
print(response.text)
# Example response:
#   The sky appears blue due to a phenomenon called Rayleigh scattering.
#   Sunlight, which contains all colors of the rainbow, is scattered
#   by the tiny particles in the Earth's atmosphere....
#   ...

Passaggi successivi

• Utilizzare Pinecone con Vertex AI RAG Engine