Usar um banco de dados do Weaviate com o mecanismo de RAG da Vertex AI

Nesta página, mostramos como conectar seu corpus do mecanismo RAG ao banco de dados Weaviate.

Você também pode acompanhar usando este notebook RAG Engine com Weaviate.

É possível usar sua instância de banco de dados do Weaviate, que é um banco de dados de código aberto, com o mecanismo de RAG para indexar e realizar uma pesquisa de similaridade baseada em vetores. Uma pesquisa de similaridade é uma maneira de encontrar trechos de texto semelhantes ao texto que você está procurando, o que exige o uso de um modelo de embedding. O modelo de embedding produz dados de vetor para cada trecho de texto comparado. A pesquisa de similaridade é usada para recuperar contextos semânticos para fundamentação e retornar o conteúdo mais preciso do seu LLM.

Com o RAG Engine, você pode continuar usando sua instância de banco de dados de vetores totalmente gerenciada, que é de sua responsabilidade provisionar. O mecanismo de RAG usa o banco de dados de vetores para armazenamento, gerenciamento de índice e pesquisa.

Considerações

Considere as seguintes etapas antes de usar o banco de dados do Weaviate:

1. É necessário criar, configurar e implantar a instância e a coleção do banco de dados do Weaviate. Siga as instruções em Criar sua coleção do Weaviate para configurar uma coleção com base no seu esquema.
2. É necessário fornecer uma chave de API do Weaviate, que permite que o mecanismo de RAG interaja com o banco de dados do Weaviate. O mecanismo RAG é compatível com AuthN e AuthZ baseados em chaves de API, que se conectam ao seu banco de dados Weaviate e oferecem suporte a uma conexão HTTPS.
3. O RAG Engine não armazena nem gerencia sua chave de API do Weaviate. Em vez disso, faça o seguinte:
   1. Armazene sua chave no Google Cloud Secret Manager.
   2. Conceda permissões à conta de serviço do projeto para acessar o secret.
   3. Conceda ao RAG Engine acesso ao nome do recurso do secret.
   4. Quando você interage com o banco de dados do Weaviate, o mecanismo de RAG acessa seu recurso secreto usando sua conta de serviço.
4. O corpus do mecanismo de RAG e a coleção do Weaviate têm um mapeamento de um para um. Os arquivos RAG são armazenados em uma coleção de banco de dados do Weaviate. Quando uma chamada é feita para a API CreateRagCorpus ou UpdateRagCorpus, o corpus RAG é associado à coleção de banco de dados.
5. Além das pesquisas semânticas baseadas em embeddings densos, a pesquisa híbrida também é compatível com o mecanismo RAG por um banco de dados Weaviate. Também é possível ajustar o peso entre a similaridade de vetores densos e esparsos em uma pesquisa híbrida.

Provisionar o banco de dados do Weaviate

Antes de usar o banco de dados Weaviate com o mecanismo RAG, faça o seguinte:

1. Configure e implante a instância do banco de dados do Weaviate.
2. Prepare o endpoint HTTPS.
3. Crie sua coleção do Weaviate.
4. Use sua chave de API para provisionar o Weaviate usando AuthN e AuthZ.
5. Provisione sua conta de serviço do RAG Engine.

Configurar e implantar a instância do banco de dados do Weaviate

Siga o guia de início rápido oficial do Weaviate. No entanto, você pode usar o Google Cloud guia do Marketplace, que é opcional.

Você pode configurar sua instância do Weaviate em qualquer lugar, desde que o endpoint do Weaviate esteja acessível para configuração e implantação no seu projeto. Depois disso, você pode gerenciar totalmente a instância do banco de dados do Weaviate.

Como o RAG Engine não está envolvido em nenhuma etapa do ciclo de vida da instância do banco de dados do Weaviate, é sua responsabilidade conceder permissões a ele para que possa armazenar e pesquisar dados no banco de dados do Weaviate. Também é sua responsabilidade garantir que os dados no seu banco de dados possam ser usados pelo RAG Engine. Por exemplo, se você mudar seus dados, o RAG Engine não será responsável por comportamentos inesperados devido a essas mudanças.

Preparar o endpoint HTTPS

Durante o provisionamento do Weaviate, crie um endpoint HTTPS. Embora as conexões HTTP sejam aceitas, preferimos que o tráfego do mecanismo de RAG e do banco de dados Weaviate use uma conexão HTTPS.

Criar sua coleção do Weaviate

Como o corpus do RAG Engine e a coleção do Weaviate têm um mapeamento individual, é necessário criar uma coleção no banco de dados do Weaviate antes de associar a coleção ao corpus do RAG Engine. Essa associação única é feita quando você chama a API CreateRagCorpus ou UpdateRagCorpus.

Ao criar uma coleção no Weaviate, use o seguinte esquema:

Use sua chave de API para provisionar o Weaviate usando AuthN e AuthZ

O provisionamento da chave de API do Weaviate envolve as seguintes etapas:

1. Crie a chave de API do Weaviate.
2. Configure o Weaviate usando sua chave de API do Weaviate.
3. Armazene sua chave de API do Weaviate no Secret Manager.

Criar a chave de API

O mecanismo de RAG só pode se conectar às instâncias do banco de dados Weaviate usando sua chave de API para autenticação e autorização. Siga o guia oficial de autenticação do Weaviate (link em inglês) para configurar a autenticação baseada em chave de API na instância do banco de dados do Weaviate.

Se a criação da chave de API do Weaviate exigir informações de identidade para associar a que vem do RAG Engine, crie seu primeiro corpus e use sua conta de serviço do RAG Engine como uma identidade.

Armazenar sua chave de API no Secret Manager

Uma chave de API contém informações sensíveis de identificação pessoal (SPII), que estão sujeitas a requisitos legais. Se os dados de SPII forem comprometidos ou usados indevidamente, uma pessoa poderá sofrer um risco ou dano significativo. Para minimizar os riscos a um indivíduo ao usar o mecanismo de RAG, não armazene nem gerencie sua chave de API e evite compartilhar a chave não criptografada.

Para proteger as SPII, faça o seguinte:

1. Armazene sua chave de API no Secret Manager.
2. Conceda à conta de serviço do RAG Engine as permissões para seus secrets e gerencie o controle de acesso no nível do recurso secreto.
   1. Navegue até as permissões do projeto.
   2. Ative a opção Incluir concessões de papel fornecidas pelo Google.
   3. Encontre a conta de serviço, que tem o formato

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

   4. Edite os principais da conta de serviço.
   5. Adicione o papel Acessador de secrets do Secret Manager à conta de serviço.
3. Durante a criação ou atualização do corpus de RAG, transmita o nome do recurso secreto para o mecanismo de RAG e armazene o nome do recurso secreto.

Quando você faz solicitações de API para suas instâncias de banco de dados do Weaviate, o RAG Engine usa cada conta de serviço para ler a chave de API que corresponde aos seus recursos secretos no Secret Manager dos seus projetos.

Provisionar a conta de serviço do RAG Engine

Quando você cria o primeiro recurso no projeto, o RAG Engine cria uma conta de serviço dedicada. É possível encontrar sua conta de serviço na página do IAM do projeto. A conta de serviço segue este formato:

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

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

Ao fazer a integração com o banco de dados do Weaviate, sua conta de serviço é usada nos seguintes cenários:

• Você pode usar sua conta de serviço para gerar a chave de API do Weaviate para autenticação. Em alguns casos, a geração da chave de API não exige informações do usuário, o que significa que uma conta de serviço não é necessária.
• Você pode vincular sua conta de serviço à chave de API no banco de dados do Weaviate para configurar a autenticação (AuthN) e a autorização (AuthZ). No entanto, sua conta de serviço não é obrigatória.
• Você pode armazenar a chave de API no Secret Manager do seu projeto e conceder à sua conta de serviço permissões para esses recursos secretos.
• O RAG Engine usa contas de serviço para acessar a chave de API do Secret Manager nos seus projetos.

Configurar o ambiente do console Google Cloud

Preparar o corpus RAG

Para acessar dados do banco de dados do Weaviate, o RAG Engine precisa ter acesso a um corpus de RAG. Esta seção mostra as etapas para criar um único corpus RAG e outros corpora RAG.

Usar as APIs CreateRagCorpus e UpdateRagCorpus

É necessário especificar os seguintes campos ao chamar as APIs CreateRagCorpus e UpdateRagCorpus:

• rag_vector_db_config.weaviate: depois de chamar a API CreateRagCorpus, a configuração do banco de dados de vetores é escolhida. A configuração do banco de dados de vetores contém todos os campos de configuração. Se o campo rag_vector_db_config.weaviate não estiver definido, rag_vector_db_config.rag_managed_db será definido por padrão.
• weaviate.http_endpoint: o endpoint HTTPS ou HTTP do Weaviate é criado durante o provisionamento da instância do banco de dados do Weaviate.
• weaviate.collection_name: o nome da coleção criada durante o provisionamento da instância do Weaviate. O nome precisa começar com uma letra maiúscula.
• api_auth.api_key_config: a configuração especifica o uso de uma chave de API para autorizar seu acesso ao banco de dados de vetores.
• api_key_config.api_key_secret_version: o nome do recurso do secret armazenado no Secret Manager, que contém sua chave de API do Weaviate.

Você pode criar e associar seu corpus de RAG à coleção do Weaviate na instância do banco de dados. No entanto, talvez você precise da conta de serviço para gerar sua chave de API e configurar a instância do banco de dados do Weaviate. Quando você cria seu primeiro corpus de RAG, a conta de serviço é gerada. Depois de criar seu primeiro corpus de RAG, a associação entre o banco de dados do Weaviate e a chave de API pode não estar pronta para uso na criação de outro corpus de RAG.

Caso seu banco de dados e sua chave não estejam prontos para serem associados ao corpus de RAG, faça o seguinte:

1. Defina o campo weaviate em rag_vector_db_config.

   • Não é possível mudar o banco de dados de vetores associado.
   • Deixe os campos http_endpoint e collection_name vazios. Os dois campos podem ser atualizados mais tarde.

2. Se você não tiver a chave de API armazenada no Secret Manager, deixe o campo api_auth vazio. Ao chamar a API UpdateRagCorpus, é possível atualizar o campo api_auth. O Weaviate exige que o seguinte seja feito:

   1. Defina o api_key_config no campo api_auth.

   2. Defina o api_key_secret_version da sua chave de API do Weaviate no Secret Manager. O campo api_key_secret_version usa o seguinte formato:

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

3. Se você especificar campos que só podem ser definidos uma vez, como http_endpoint ou collection_name, não será possível mudá-los, a menos que você exclua o corpus RAG e o crie novamente. Outros campos, como a chave de API, api_key_secret_version, podem ser atualizados.

4. Ao chamar UpdateRagCorpus, você pode definir o campo vector_db. O vector_db precisa ser definido como weaviate pela chamada de API CreateRagCorpus. Caso contrário, o sistema vai escolher a opção Banco de dados gerenciado de RAG, que é a padrão. Essa opção não pode ser alterada ao chamar a API UpdateRagCorpus. Quando você chama UpdateRagCorpus e o campo vector_db está parcialmente definido, é possível atualizar os campos marcados como Mutáveis (também chamados de mutáveis).

Esta tabela lista os campos mutáveis e imutáveis de WeaviateConfig usados no seu código.

Criar o primeiro corpus RAG

Quando a conta de serviço do RAG Engine não existir, faça o seguinte:

1. Crie um corpus RAG no mecanismo RAG com uma configuração vazia do Weaviate, que inicia o provisionamento do mecanismo RAG para criar uma conta de serviço.
2. Escolha um nome para sua conta de serviço do RAG Engine que siga este formato:
   

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

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

3. Usando sua conta de serviço, acesse o secret armazenado no Secret Manager do projeto, que contém sua chave de API do Weaviate.
4. Receba as seguintes informações depois que o provisionamento do Weaviate for concluído:
   • Seu endpoint HTTPS ou HTTP do Weaviate.
   • O nome da sua coleção do Weaviate.
5. Chame a API CreateRagCorpus para criar um corpus de RAG com uma configuração do Weaviate vazia e chame a API UpdateRagCorpus para atualizar o corpus de RAG com as seguintes informações:
   • Seu endpoint HTTPS ou HTTP do Weaviate.
   • O nome da sua coleção do Weaviate.
   • O nome do recurso da chave de API.

Criar outro corpus RAG

Quando a conta de serviço do mecanismo RAG existir, faça o seguinte:

1. Acesse a conta de serviço do RAG Engine nas permissões do projeto.
2. Ative a opção "Incluir concessões de papel fornecidas pelo Google".
3. Escolha um nome para sua conta de serviço do RAG Engine que siga este formato:
   

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

4. Usando sua conta de serviço, acesse o secret armazenado no Secret Manager do projeto, que contém sua chave de API do Weaviate.
5. Durante o provisionamento do Weaviate, colete as seguintes informações:
   • O endpoint HTTPS ou HTTP do Weaviate.
   • O nome da sua coleção do Weaviate.
6. Crie um corpus de RAG no mecanismo RAG e conecte-o à sua coleção do Weaviate fazendo uma das seguintes ações:
   1. Faça uma chamada de API CreateRagCorpus para criar um corpus RAG com uma configuração do Weaviate preenchida, que é a opção preferida.
   2. Faça uma chamada de API CreateRagCorpus para criar um corpus RAG com uma configuração vazia do Weaviate e uma chamada de API UpdateRagCorpus para atualizar o corpus RAG com as seguintes informações:
      • Endpoint HTTP do banco de dados Weaviate
      • Nome da coleção do Weaviate
      • Chave de API

Exemplos

Esta seção apresenta um exemplo de código que demonstra como configurar seu banco de dados Weaviate, o Secret Manager, o corpus RAG e o arquivo RAG. Também fornecemos um exemplo de código para demonstrar como importar arquivos, recuperar contexto, gerar conteúdo e excluir o corpus e os arquivos RAG.

Para usar o notebook da API RAG do Model Garden, consulte Usar o Weaviate com o Llama 3.

Configurar o banco de dados do Weaviate

Este exemplo de código demonstra como configurar seus dados do Weaviate e o 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

Configurar o Secret Manager

Para configurar o Secret Manager, é necessário ativar o serviço e definir permissões.

Criar Secret

Para ativar o Secret Manager, faça o seguinte:

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

Definir permissões

Conceda permissões do Secret Manager à sua conta de serviço.

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

Adicionar versão do 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}")

Usar o Weaviate com o Llama 3

O notebook da API RAG do Model Garden demonstra como usar o SDK da Vertex AI para Python com um corpus do Weaviate e um modelo do Llama 3. Para usar o notebook, faça o seguinte:

1. Configure seu banco de dados do Weaviate.

2. Configure o Secret Manager.

3. Use o notebook da API RAG do Model Garden.

Para mais exemplos, consulte Exemplos.

Criar um corpus RAG

Este exemplo de código demonstra como criar um corpus RAG e define a instância do Weaviate como o banco de dados de vetores dele.

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

Usar o arquivo RAG

A API RAG processa o upload, a importação, a listagem e a exclusão de arquivos.

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

Importar arquivos RAG

É possível importar arquivos e pastas do Drive ou do 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.

Acessar um arquivo 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')

Listar arquivos 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

Excluir um arquivo 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.

Recuperar contexto

Quando um usuário faz uma pergunta ou fornece uma solicitação, o componente de recuperação no RAG pesquisa em sua base de conhecimento para encontrar informações relevantes para a consulta.

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: "....
#   ....

Gera conteúdo

Uma previsão controla o método LLM que gera conteúdo.

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

Pesquisa híbrida

A pesquisa híbrida é compatível com o banco de dados Weaviate, que combina pesquisas semânticas e por palavra-chave para melhorar a relevância dos resultados. Durante a recuperação dos resultados da pesquisa, uma combinação de pontuações de similaridade da correspondência semântica (um vetor denso) e de palavras-chave (um vetor esparso) produz os resultados finais classificados.

Pesquisa híbrida usando a API de recuperação do mecanismo de RAG

Este é um exemplo de como ativar uma pesquisa híbrida usando a API de recuperação do mecanismo RAG.

  # 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: "....
#   ....

Usar a pesquisa híbrida e o mecanismo RAG para geração embasada

Este é um exemplo de como usar a pesquisa híbrida e o mecanismo RAG para geração embasada.

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

A seguir

• Usar o Pinecone com o mecanismo de RAG da Vertex AI