A partire dal 29 aprile 2025, i modelli Gemini 1.5 Pro e Gemini 1.5 Flash non sono disponibili nei progetti che non li hanno mai utilizzati, inclusi i nuovi progetti. Per maggiori dettagli, vedi Versioni e ciclo di vita dei modelli.

Questa pagina è stata tradotta dall'API Cloud Translation.

API RAG Engine

RAG Engine di Vertex AI è un componente della piattaforma Vertex AI, che facilita la generazione RAG (Retrieval-Augmented Generation). RAG Engine consente ai modelli linguistici di grandi dimensioni (LLM) di accedere e incorporare dati da origini di conoscenza esterne, come documenti e database. Utilizzando i RAG, gli LLM possono generare risposte LLM più accurate e informative.

Elenco dei parametri

In questa sezione sono elencate le seguenti informazioni:

Parametri	Esempi
Consulta Parametri di gestione del corpus.	Consulta gli esempi di gestione del corpus.
Consulta Parametri di gestione dei file.	Consulta gli esempi di gestione dei file.

Parametri di gestione del corpus

Per informazioni su un corpus RAG, consulta Gestione di Corpus.

Crea un corpus RAG

In questa tabella sono elencati i parametri utilizzati per creare un corpus RAG.

Corpo della richiesta

Parametri
`display_name`	Obbligatorio: `string` Il nome visualizzato del corpus RAG.
`description`	Facoltativo: `string` La descrizione del corpus RAG.
`vector_db_config`	Facoltativo: immutabile: `RagVectorDbConfig` La configurazione dei database vettoriali.
`vertex_ai_search_config.serving_config`	Facoltativo: `string` La configurazione di Vertex AI Search. Formato: `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}/servingConfigs/{serving_config}` o `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/servingConfigs/{serving_config}`

`RagVectorDbConfig`

Parametri
`rag_managed_db`	`oneof` `vector_db`: `RagVectorDbConfig.RagManagedDb` Se non viene specificato alcun database vettoriale, `rag_managed_db` è il database vettoriale predefinito.
`pinecone`	`oneof` `vector_db`: `RagVectorDbConfig.Pinecone` Specifica la tua istanza Pinecone.
`pinecone.index_name`	`string` Si tratta del nome utilizzato per creare l'indice della pigna da utilizzare con il corpus RAG. Una volta impostato, questo valore non può essere modificato. Puoi lasciarlo vuoto nella chiamata API `CreateRagCorpus` e impostarlo con un valore non vuoto in una chiamata API `UpdateRagCorpus` successiva.
`vertex_vector_search`	`oneof` `vector_db`: `RagVectorDbConfig.VertexVectorSearch` Specifica la tua istanza di Vertex Vector Search.
`vertex_vector_search.index`	`string` Questo è il nome della risorsa dell'indice di Vector Search utilizzato con il corpus RAG. Formato: `projects/{project}/locations/{location}/indexEndpoints/{index_endpoint}` Una volta impostato, questo valore non può essere modificato. Puoi lasciarlo vuoto nella chiamata API `CreateRagCorpus` e impostarlo con un valore non vuoto in una chiamata API `UpdateRagCorpus` successiva.
`vertex_vector_search.index_endpoint`	`string` Questo è il nome della risorsa dell'endpoint indice di Vector Search utilizzato con il corpus RAG. Formato: `projects/{project}/locations/{location}/indexes/{index}` Una volta impostato, questo valore non può essere modificato. Puoi lasciarlo vuoto nella chiamata API `CreateRagCorpus` e impostarlo con un valore non vuoto in una chiamata API `UpdateRagCorpus` successiva.
`api_auth.api_key_config.api_key_secret_version`	`string` Si tratta del nome completo della risorsa del secret archiviato in Secret Manager, che contiene la chiave API Pinecone. Formato: `projects/{PROJECT_NUMBER}/secrets/{SECRET_ID}/versions/{VERSION_ID}` Puoi lasciarlo vuoto nella chiamata API `CreateRagCorpus` e impostarlo con un valore non vuoto in una chiamata API `UpdateRagCorpus` successiva.
`rag_embedding_model_config.vertex_prediction_endpoint.endpoint`	Facoltativo: immutabile: `string` Il modello di incorporamento da utilizzare per il corpus RAG. Questo valore non può essere modificato dopo essere stato impostato. Se lasci vuoto il campo, utilizziamo text-embedding-005 come modello di incorporamento.

Aggiorna un corpus RAG

In questa tabella sono elencati i parametri utilizzati per aggiornare un corpus RAG.

Corpo della richiesta

Parametri
`display_name`	Facoltativo: `string` Il nome visualizzato del corpus RAG.
`description`	Facoltativo: `string` La descrizione del corpus RAG.
`rag_vector_db.pinecone.index_name`	`string` Si tratta del nome utilizzato per creare l'indice della pigna da utilizzare con il corpus RAG. Se `RagCorpus` è stato creato con una configurazione `Pinecone` e questo campo non è mai stato impostato prima, puoi aggiornare il nome indice dell'istanza Pinecone.
`rag_vector_db.vertex_vector_search.index`	`string` Questo è il nome della risorsa dell'indice di Vector Search utilizzato con il corpus RAG. Formato: `projects/{project}/locations/{location}/indexEndpoints/{index_endpoint}` Se `RagCorpus` è stato creato con una configurazione `Vector Search` e questo campo non è mai stato impostato prima, puoi aggiornarlo.
`rag_vector_db.vertex_vector_search.index_endpoint`	`string` Questo è il nome della risorsa dell'endpoint indice di Vector Search utilizzato con il corpus RAG. Formato: `projects/{project}/locations/{location}/indexes/{index}` Se `RagCorpus` è stato creato con una configurazione `Vector Search` e questo campo non è mai stato impostato prima, puoi aggiornarlo.
`rag_vector_db.api_auth.api_key_config.api_key_secret_version`	`string` Il nome completo della risorsa del secret archiviato in Secret Manager, che contiene la chiave API Pinecone. Formato: `projects/{PROJECT_NUMBER}/secrets/{SECRET_ID}/versions/{VERSION_ID}`

Elenco corpora RAG

Questa tabella elenca i parametri utilizzati per elencare il corpora RAG.

Parametri

Parametri
`page_size`	Facoltativo: `int` Le dimensioni della pagina dell'elenco standard.
`page_token`	Facoltativo: `string` Il token della pagina dell'elenco standard. Risultato ottenuto in genere da `[ListRagCorporaResponse.next_page_token][]` della chiamata `[VertexRagDataService.ListRagCorpora][]` precedente.

page_size

Facoltativo: int

Le dimensioni della pagina dell'elenco standard.

page_token

Facoltativo: string

Il token della pagina dell'elenco standard. Risultato ottenuto in genere da [ListRagCorporaResponse.next_page_token][] della chiamata [VertexRagDataService.ListRagCorpora][] precedente.

Ottieni un corpus RAG

In questa tabella sono elencati i parametri utilizzati per ottenere un corpus RAG.

Parametri

Parametri
`name`	`string` Il nome della risorsa `RagCorpus`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}`

name

string

Il nome della risorsa RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}

Elimina un corpus RAG

In questa tabella sono elencati i parametri utilizzati per eliminare un corpus RAG.

Parametri

Parametri
`name`	`string` Il nome della risorsa `RagCorpus`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}`

name

string

Il nome della risorsa RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}

Parametri di gestione dei file

Per informazioni su un file RAG, consulta Gestione dei file.

Carica un file RAG

In questa tabella sono elencati i parametri utilizzati per caricare un file RAG.

Corpo della richiesta

Parametri

Parametri
`parent`	`string` Il nome della risorsa `RagCorpus`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}`
`rag_file`	Obbligatorio: `RagFile` Il file da caricare.
`upload_rag_file_config`	Obbligatorio: `UploadRagFileConfig` La configurazione di `RagFile` da caricare in `RagCorpus`.

parent

string

Il nome della risorsa RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}

rag_file

Obbligatorio: RagFile

Il file da caricare.

upload_rag_file_config

Obbligatorio: UploadRagFileConfig

La configurazione di RagFile da caricare in RagCorpus.

`RagFile`
`display_name`	Obbligatorio: `string` Il nome visualizzato del file RAG.
`description`	Facoltativo: `string` La descrizione del file RAG.

RagFile

display_name

Obbligatorio: string

Il nome visualizzato del file RAG.

description

Facoltativo: string

La descrizione del file RAG.

`UploadRagFileConfig`
`rag_file_transformation_config.rag_file_chunking_config.fixed_length_chunking.chunk_size`	`int32` Numero di token di ciascun blocco.
`rag_file_transformation_config.rag_file_chunking_config.fixed_length_chunking.chunk_overlap`	`int32` La sovrapposizione tra i chunk.

UploadRagFileConfig

rag_file_transformation_config.rag_file_chunking_config.fixed_length_chunking.chunk_size

int32

Numero di token di ciascun blocco.

rag_file_transformation_config.rag_file_chunking_config.fixed_length_chunking.chunk_overlap

int32

La sovrapposizione tra i chunk.

Importa file RAG

In questa tabella sono elencati i parametri utilizzati per importare un file RAG.

Parametri
`parent`	Obbligatorio: `string` Il nome della risorsa `RagCorpus`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus_id}`
`gcs_source`	`oneof` `import_source`: `GcsSource` Percorso di Cloud Storage. Supporta l'importazione di singoli file e di intere directory di Cloud Storage.
`gcs_source.uris`	`list` di `string` URI Cloud Storage che contiene il file di caricamento.
`google_drive_source`	`oneof` `import_source`: `GoogleDriveSource` Posizione di Google Drive. Supporta l'importazione di singoli file e di cartelle di Google Drive.
`slack_source`	`oneof` `import_source`: `SlackSource` Il canale Slack in cui viene caricato il file.
`jira_source`	`oneof` `import_source`: `JiraSource` La query Jira in cui viene caricato il file.
`share_point_sources`	`oneof` `import_source`: `SharePointSources` Le origini di SharePoint in cui viene caricato il file.
`rag_file_transformation_config.rag_file_chunking_config.fixed_length_chunking.chunk_size`	`int32` Numero di token di ciascun blocco.
`rag_file_transformation_config.rag_file_chunking_config.fixed_length_chunking.chunk_overlap`	`int32` La sovrapposizione tra i chunk.
`rag_file_parsing_config`	Facoltativo: `RagFileParsingConfig` Specifica la configurazione dell'analisi per `RagFiles`. Se questo campo non è impostato, RAG utilizza il parser predefinito.
`max_embedding_requests_per_min`	Facoltativo: `int32` Il numero massimo di query al minuto che questo job può eseguire al modello di incorporamento specificato nel corpus. Questo valore è specifico per questo job e non è condiviso tra altri job di importazione. Consulta la pagina Quote del progetto per impostare un valore appropriato. Se non specificato, viene utilizzato un valore predefinito di 1000 QPM.

`GoogleDriveSource`
`resource_ids.resource_id`	Obbligatorio: `string` L'ID della risorsa di Google Drive.
`resource_ids.resource_type`	Obbligatorio: `string` Il tipo di risorsa di Google Drive.

GoogleDriveSource

resource_ids.resource_id

Obbligatorio: string

L'ID della risorsa di Google Drive.

resource_ids.resource_type

Obbligatorio: string

Il tipo di risorsa di Google Drive.

`SlackSource`
`channels.channels`	Ripetizione: `SlackSource.SlackChannels.SlackChannel` Informazioni sul canale Slack, inclusi ID e intervallo di tempo da importare.
`channels.channels.channel_id`	Obbligatorio: `string` L'ID canale di Slack.
`channels.channels.start_time`	Facoltativo: `google.protobuf.Timestamp` Il timestamp iniziale per i messaggi da importare.
`channels.channels.end_time`	Facoltativo: `google.protobuf.Timestamp` Il timestamp di fine dei messaggi da importare.
`channels.api_key_config.api_key_secret_version`	Obbligatorio: `string` Il nome completo della risorsa del secret archiviato in Secret Manager, che contiene un token di accesso al canale Slack che ha accesso agli ID canale Slack. Vedi: https://api.slack.com/tutorials/tracks/getting-a-token. Formato: `projects/{PROJECT_NUMBER}/secrets/{SECRET_ID}/versions/{VERSION_ID}`

`JiraSource`
`jira_queries.projects`	Ripetizione: `string` Un elenco di progetti Jira da importare nella loro interezza.
`jira_queries.custom_queries`	Ripetizione: `string` Un elenco di query Jira personalizzate da importare. Per informazioni sul linguaggio JQL (Jira Query Language), consulta l'assistenza Jira
`jira_queries.email`	Obbligatorio: `string` L'indirizzo email Jira.
`jira_queries.server_uri`	Obbligatorio: `string` L'URI del server Jira.
`jira_queries.api_key_config.api_key_secret_version`	Obbligatorio: `string` Il nome completo della risorsa del secret archiviato in Secret Manager, che contiene la chiave API Jira che ha accesso agli ID canale Slack. Vedi: https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/ Formato: `projects/{PROJECT_NUMBER}/secrets/{SECRET_ID}/versions/{VERSION_ID}`

`SharePointSources`
`share_point_sources.sharepoint_folder_path`	`oneof` a `folder_source`: `string` Il percorso della cartella SharePoint da cui eseguire il download.
`share_point_sources.sharepoint_folder_id`	`oneof` a `folder_source`: `string` L'ID della cartella SharePoint da cui eseguire il download.
`share_point_sources.drive_name`	`oneof` a `drive_source`: `string` Il nome dell'unità da cui eseguire il download.
`share_point_sources.drive_id`	`oneof` a `drive_source`: `string` L'ID dell'unità da cui eseguire il download.
`share_point_sources.client_id`	`string` L'ID dell'app registrata nel portale Microsoft Azure. L'applicazione deve inoltre essere configurata con le autorizzazioni di MS Graph "Files.ReadAll", "Sites.ReadAll" e BrowserSiteLists.Read.All.
`share_point_sources.client_secret.api_key_secret_version`	Obbligatorio: `string` Il nome completo della risorsa del secret archiviato in Secret Manager, che contiene il secret dell'applicazione per l'app registrata in Azure. Formato: `projects/{PROJECT_NUMBER}/secrets/{SECRET_ID}/versions/{VERSION_ID}`
`share_point_sources.tenant_id`	`string` Identificatore univoco dell'istanza Azure Active Directory.
`share_point_sources.sharepoint_site_name`	`string` Il nome del sito SharePoint da cui eseguire il download. Può essere il nome o l'ID del sito.

`RagFileParsingConfig`
`layout_parser`	`oneof` `parser`: `RagFileParsingConfig.LayoutParser` L'analizzatore sintattico del layout da utilizzare per i `RagFile`.
`layout_parser.processor_name`	`string` Il nome completo della risorsa di un processore o versione del processore Document AI. Formato: `projects/{project_id}/locations/{location}/processors/{processor_id}` `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`
`layout_parser.max_parsing_requests_per_min`	`string` Il numero massimo di richieste al minuto che il job può inviare al processore Document AI. Consulta la pagina https://cloud.google.com/document-ai/quotas e la pagina Quota per il tuo progetto per impostare un valore appropriato qui. Se non specificato, viene utilizzato un valore predefinito di 120 QPM.

RagFileParsingConfig

layout_parser

oneof parser: RagFileParsingConfig.LayoutParser

L'analizzatore sintattico del layout da utilizzare per i RagFile.

layout_parser.processor_name

string

Il nome completo della risorsa di un processore o versione del processore Document AI.

Formato:
projects/{project_id}/locations/{location}/processors/{processor_id}
projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}

layout_parser.max_parsing_requests_per_min

string

Il numero massimo di richieste al minuto che il job può inviare al processore Document AI.

Consulta la pagina https://cloud.google.com/document-ai/quotas e la pagina Quota per il tuo progetto per impostare un valore appropriato qui. Se non specificato, viene utilizzato un valore predefinito di 120 QPM.

Recuperare un file RAG

In questa tabella sono elencati i parametri utilizzati per ottenere un file RAG.

Parametri

Parametri
`name`	`string` Il nome della risorsa `RagFile`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_file_id}`

name

string

Il nome della risorsa RagFile. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_file_id}

Eliminare un file RAG

In questa tabella sono elencati i parametri utilizzati per eliminare un file RAG.

Parametri

Parametri
`name`	`string` Il nome della risorsa `RagFile`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_file_id}`

name

string

Il nome della risorsa RagFile. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_file_id}

Recupero e previsione

In questa sezione sono elencati i parametri di recupero e previsione.

Parametri di recupero

In questa tabella sono elencati i parametri per l'API retrieveContexts.

Parametri

Parametri
`parent`	Obbligatorio: `string` Il nome della risorsa della località in cui recuperare `RagContexts`. Gli utenti devono disporre dell'autorizzazione per effettuare una chiamata nel progetto. Formato: `projects/{project}/locations/{location}`
`vertex_rag_store`	`VertexRagStore` L'origine dati per Vertex RagStore.
`query`	Obbligatorio: `RagQuery` Singola query di recupero RAG.

parent

Obbligatorio: string

Il nome della risorsa della località in cui recuperare RagContexts.
Gli utenti devono disporre dell'autorizzazione per effettuare una chiamata nel progetto.

Formato: projects/{project}/locations/{location}

vertex_rag_store

VertexRagStore

L'origine dati per Vertex RagStore.

query

Obbligatorio: RagQuery

Singola query di recupero RAG.

`VertexRagStore`

`VertexRagStore`
`rag_resources`	elenco: `RagResource` La rappresentazione dell'origine RAG. Può essere utilizzato per specificare solo il corpus o i `RagFile`. Supporta uno o più file di un unico corpus.
`rag_resources.rag_corpus`	Facoltativo: `string` Nome risorsa `RagCorpora`. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus}`
`rag_resources.rag_file_ids`	elenco: `string` Un elenco di `RagFile` risorse. Formato: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus}/ragFiles/{rag_file}`

VertexRagStore

rag_resources

elenco: RagResource

La rappresentazione dell'origine RAG. Può essere utilizzato per specificare solo il corpus o i RagFile. Supporta uno o più file di un unico corpus.

rag_resources.rag_corpus

Facoltativo: string

Nome risorsa RagCorpora.

Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}

rag_resources.rag_file_ids

elenco: string

Un elenco di RagFile risorse.

Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}/ragFiles/{rag_file}

`RagQuery`
`text`	`string` La query in formato testuale per ottenere contesti pertinenti.
`rag_retrieval_config`	Facoltativo: `RagRetrievalConfig` La configurazione di recupero per la query.

RagQuery

text

string

La query in formato testuale per ottenere contesti pertinenti.

rag_retrieval_config

Facoltativo: RagRetrievalConfig

La configurazione di recupero per la query.

`RagRetrievalConfig`
`top_k`	Facoltativo: `int32` Il numero di contesti da recuperare.
`filter.vector_distance_threshold`	`oneof vector_db_threshold`: `double` Restituisce solo i contesti con una distanza vettoriale minore della soglia.
`filter.vector_similarity_threshold`	`oneof vector_db_threshold`: `double` Restituisce solo i contesti con somiglianza vettoriale maggiore della soglia.
`ranking.rank_service.model_name`	Facoltativo: `string` Il nome del modello del servizio di ranking. Esempio: `semantic-ranker-512@latest`
`ranking.llm_ranker.model_name`	Facoltativo: `string` Il nome del modello utilizzato per il ranking. Esempio: `gemini-2.0-flash`

Parametri di previsione

In questa tabella sono elencati i parametri di previsione.

`GenerateContentRequest`
`tools.retrieval.vertex_rag_store`	`VertexRagStore` Imposta l'utilizzo di un'origine dati basata sul RAG Store di Vertex AI.

GenerateContentRequest

tools.retrieval.vertex_rag_store

VertexRagStore

Imposta l'utilizzo di un'origine dati basata sul RAG Store di Vertex AI.

Vedi VertexRagStore per i dettagli.

Esempi di gestione dei corpus

Questa sezione fornisce esempi di come utilizzare l'API per gestire il tuo corpus RAG.

Crea un esempio di corpus RAG

Questi esempi di codice mostrano come creare un corpus RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
CORPUS_DISPLAY_NAME: il nome visualizzato del corpus RAG.
CORPUS_DESCRIPTION: la descrizione del corpus RAG.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora

Corpo JSON della richiesta:

{
  "display_name" : "CORPUS_DISPLAY_NAME",
  "description": "CORPUS_DESCRIPTION",
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora"

Powershell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

  $cred = gcloud auth print-access-token
  $headers = @{ "Authorization" = "Bearer $cred" }

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

Dovresti ricevere un codice di stato corretto (2xx).

L'esempio seguente mostra come creare un corpus RAG utilizzando l'API REST.

  // CreateRagCorpus
  // Input: LOCATION, PROJECT_ID, CORPUS_DISPLAY_NAME
  // Output: CreateRagCorpusOperationMetadata
  curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora \
  -d '{
        "display_name" : "CORPUS_DISPLAY_NAME"
    }'

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta la documentazione di riferimento dell'SDK Vertex AI per l'API Python.


from vertexai import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# display_name = "test_corpus"
# description = "Corpus Description"

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

# Configure backend_config
backend_config = rag.RagVectorDbConfig(
    rag_embedding_model_config=rag.RagEmbeddingModelConfig(
        vertex_prediction_endpoint=rag.VertexPredictionEndpoint(
            publisher_model="publishers/google/models/text-embedding-005"
        )
    )
)

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

Aggiorna un esempio di corpus RAG

Puoi aggiornare il corpus RAG con un nuovo nome visualizzato, una nuova descrizione e una nuova configurazione del database vettoriale. Tuttavia, non puoi modificare i seguenti parametri nel corpus RAG:

Il tipo di database vettoriale. Ad esempio, non puoi cambiare il database vettoriale da Weaviate a Vertex AI Feature Store.
Se utilizzi l'opzione database gestito, non puoi aggiornare la configurazione del database vettoriale.

Questi esempi mostrano come aggiornare un corpus RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
CORPUS_ID: l'ID del corpus RAG.
CORPUS_DISPLAY_NAME: il nome visualizzato del corpus RAG.
CORPUS_DESCRIPTION: la descrizione del corpus RAG.
INDEX_NAME: il nome della risorsa dell'indice di Vector Search. Formato: projects/{project}/locations/{location}/indexes/{index}.
INDEX_ENDPOINT_NAME: il nome della risorsa dell'endpoint indice di Vector Search. Formato: projects/{project}/locations/{location}/indexEndpoints/{index_endpoint}.

Metodo HTTP e URL:

PATCH https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/CORPUS_ID

Corpo JSON della richiesta:

{
  "display_name" : "CORPUS_DISPLAY_NAME",
  "description": "CORPUS_DESCRIPTION",
  "rag_vector_db_config": {
    "vertex_vector_search": {
        "index": "INDEX_NAME",
        "index_endpoint": "INDEX_ENDPOINT_NAME",
    }
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X PATCH \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/CORPUS_ID"

Powershell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Dovresti ricevere un codice di stato corretto (2xx).

Elenco di corpora RAG di esempio

Questi esempi di codice mostrano come elencare tutti i corpora RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
PAGE_SIZE: la dimensione standard della pagina di elenco. Puoi regolare il numero di corpora RAG da restituire per pagina aggiornando il parametro page_size.
PAGE_TOKEN: il token standard della pagina elenco. Ottenuta in genere usando ListRagCorporaResponse.next_page_token della chiamata VertexRagDataService.ListRagCorpora precedente.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Esegui questo comando:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora?page_size=PAGE_SIZE&page_token=PAGE_TOKEN"

Powershell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Dovresti ricevere un codice di stato corretto (2xx) e un elenco di corpora RAG nell'ambito PROJECT_ID specificato.

Python


from vertexai import rag
import vertexai

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"

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

corpora = rag.list_corpora()
print(corpora)
# Example response:
# ListRagCorporaPager<rag_corpora {
#   name: "projects/[PROJECT_ID]/locations/us-central1/ragCorpora/2305843009213693952"
#   display_name: "test_corpus"
#   create_time {
# ...

Ottieni un esempio di corpus RAG

Questi esempi di codice mostrano come ottenere un corpus RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID della risorsa del corpus RAG.

Metodo HTTP e URL:

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Esegui questo comando:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID"

Powershell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Una risposta positiva restituisce la risorsa RagCorpus.

I comandi get e list vengono utilizzati in un esempio per dimostrare in che modo RagCorpus utilizza il campo rag_embedding_model_config nell'elemento vector_db_config, che punta al modello di incorporamento che hai scelto.

    PROJECT_ID: Your project ID.
    LOCATION: The region to process the request.
    RAG_CORPUS_ID: The corpus ID of your RAG corpus.
  ```

```sh
  // GetRagCorpus
  // Input: LOCATION, PROJECT_ID, RAG_CORPUS_ID
  // Output: RagCorpus
  curl -X GET \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID

  // ListRagCorpora
  curl -sS -X GET \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/
  ```

Python


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

corpus = rag.get_corpus(name=corpus_name)
print(corpus)
# Example response:
# RagCorpus(name='projects/[PROJECT_ID]/locations/us-central1/ragCorpora/1234567890',
# display_name='test_corpus', description='Corpus Description',
# ...

Elimina un esempio di corpus RAG

Questi esempi di codice mostrano come eliminare un corpus RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID della risorsa RagCorpus.

Metodo HTTP e URL:

DELETE https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Esegui questo comando:

curl -X DELETE \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID"

Powershell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Una risposta corretta restituisce DeleteOperationMetadata.

Python


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

rag.delete_corpus(name=corpus_name)
print(f"Corpus {corpus_name} deleted.")
# Example response:
# Successfully deleted the RagCorpus.
# Corpus projects/[PROJECT_ID]/locations/us-central1/ragCorpora/123456789012345 deleted.

Esempi di gestione dei file

Questa sezione fornisce esempi di come utilizzare l'API per gestire i file RAG.

Carica un file RAG di esempio

Questi esempi di codice mostrano come caricare un file RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID del corpus RAG.
LOCAL_FILE_PATH: il percorso locale del file da caricare.
DISPLAY_NAME: il nome visualizzato del file RAG.
DESCRIPTION: la descrizione del file RAG.

Per inviare la richiesta, utilizza il comando seguente:

curl -X POST \
-H "X-Goog-Upload-Protocol: multipart" \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-F metadata="{'rag_file': {'display_name':' DISPLAY_NAME', 'description':'DESCRIPTION'}}" \
-F file=@LOCAL_FILE_PATH \
"https://LOCATION-aiplatform.googleapis.com/upload/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:upload"

Python


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

Esempio di importazione di file RAG

Puoi importare file e cartelle da Drive o Cloud Storage. Puoi utilizzare response.metadata per visualizzare gli errori parziali, il tempo di richiesta e il tempo di risposta nell'oggetto response dell'SDK.

response.skipped_rag_files_count si riferisce al numero di file ignorati durante l'importazione. Un file viene ignorato quando si verificano le seguenti condizioni:

Il file è già stato importato.
Il file non è cambiato.
La configurazione del chunking per il file non è cambiata.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID del corpus RAG.
FOLDER_RESOURCE_ID: l'ID risorsa della cartella di Drive.
GCS_URIS: un elenco di località di Cloud Storage. Esempio: gs://my-bucket1.
CHUNK_SIZE: il numero di token che ogni blocco dovrebbe avere.
CHUNK_OVERLAP: il numero di token che si sovrappongono tra i blocchi.
EMBEDDING_MODEL_QPM_RATE: la frequenza QPM per limitare l'accesso della RAG al modello di incorporamento. Esempio: 1000.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

{
  "import_rag_files_config": {
    "gcs_source": {
      "uris": "GCS_URIS"
    },
    "rag_file_chunking_config": {
      "chunk_size": "CHUNK_SIZE",
      "chunk_overlap": "CHUNK_OVERLAP"
    }
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles:import"

Powershell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Una risposta positiva restituisce la risorsa ImportRagFilesOperationMetadata.

L'esempio seguente mostra come importare un file da Cloud Storage. Utilizza il campo di controllo max_embedding_requests_per_min per limitare la frequenza con cui RAG Engine chiama il modello di embedding durante il processo di indicizzazione ImportRagFiles. Il campo ha un valore predefinito di 1000 chiamate al minuto.

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID del corpus RAG.
GCS_URIS: un elenco di località di Cloud Storage. Esempio: gs://my-bucket1.
CHUNK_SIZE: il numero di token che ogni blocco dovrebbe avere.
CHUNK_OVERLAP: il numero di token che si sovrappongono tra i blocchi.
EMBEDDING_MODEL_QPM_RATE: la frequenza QPM per limitare l'accesso degli RAG al modello di incorporamento. Esempio: 1000.

// ImportRagFiles
// Import a single Cloud Storage file or all files in a Cloud Storage bucket.
// Input: LOCATION, 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://LOCATION-aiplatform.googleapis.com/v1/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": CHUNK_SIZE,
      "chunk_overlap": CHUNK_OVERLAP
    },
    "max_embedding_requests_per_min": EMBEDDING_MODEL_QPM_RATE
  }
}'

L'esempio riportato di seguito mostra come importare un file da Drive. Utilizza il campo di controllo max_embedding_requests_per_min per limitare la frequenza con cui RAG Engine chiama il modello di embedding durante il processo di indicizzazione ImportRagFiles. Il campo ha un valore predefinito di 1000 chiamate al minuto.

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID del corpus RAG.
FOLDER_RESOURCE_ID: l'ID risorsa della cartella di Drive.
CHUNK_SIZE: il numero di token che ogni blocco dovrebbe avere.
CHUNK_OVERLAP: il numero di token che si sovrappongono tra i blocchi.
EMBEDDING_MODEL_QPM_RATE: la frequenza QPM per limitare l'accesso della RAG al modello di incorporamento. Esempio: 1000.

// ImportRagFiles
// Import all files in a Google Drive folder.
// Input: LOCATION, 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://LOCATION-aiplatform.googleapis.com/v1/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
  }
}'

Python


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.

Esempio di elenco di file RAG

Questi esempi di codice mostrano come elencare i file RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID della risorsa RagCorpus.
PAGE_SIZE: la dimensione standard della pagina di elenco. Puoi modificare il numero di RagFiles da restituire per pagina aggiornando il parametro page_size.
PAGE_TOKEN: il token standard della pagina elenco. ottenuta utilizzando ListRagFilesResponse.next_page_token della chiamata VertexRagDataService.ListRagFiles precedente.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Esegui questo comando:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles?page_size=PAGE_SIZE&page_token=PAGE_TOKEN"

Powershell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Dovresti ricevere un codice di stato corretto (2xx) insieme a un elenco di RagFiles sotto il RAG_CORPUS_ID specificato.

Python


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

Ottieni un esempio di file RAG

Questi esempi di codice mostrano come ottenere un file RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID della risorsa RagCorpus.
RAG_FILE_ID: l'ID della risorsa RagFile.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Esegui questo comando:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID"

Powershell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Una risposta positiva restituisce la risorsa RagFile.

Python


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

Elimina un esempio di file RAG

Questi esempi di codice mostrano come eliminare un file RAG.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID>: l'ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_ID: l'ID della risorsa RagCorpus.
RAG_FILE_ID: l'ID della risorsa RagFile. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}/ragFiles/{rag_file_id}.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Esegui questo comando:

curl -X DELETE \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/ragCorpora/RAG_CORPUS_ID/ragFiles/RAG_FILE_ID"

Powershell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Python


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.

Query di recupero

Quando un utente pone una domanda o fornisce un prompt, il componente di recupero in RAG esamina la knowledge base per trovare informazioni pertinenti alla query.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
RAG_CORPUS_RESOURCE: il nome della risorsa RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}.
VECTOR_DISTANCE_THRESHOLD: vengono restituiti solo i contesti con una distanza vettoriale inferiore alla soglia.
TEXT: il testo della query per ottenere contesti pertinenti.
SIMILARITY_TOP_K: il numero di contesti principali da recuperare.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

curl

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:retrieveContexts"

Powershell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Dovresti ricevere un codice di stato corretto (2xx) e un elenco di RagFiles correlati.

Python


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

Generazione

L'LLM genera una risposta con base utilizzando i contesti recuperati.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui elaborare la richiesta.
MODEL_ID: modello LLM per la generazione di contenuti. Esempio: gemini-2.0-flash-001.
GENERATION_METHOD: metodo LLM per la generazione di contenuti. Opzioni: generateContent, streamGenerateContent.
INPUT_PROMPT: il testo inviato all'LLM per la generazione di contenuti. Prova a utilizzare un prompt pertinente ai file rag caricati.
RAG_CORPUS_RESOURCE: il nome della risorsa RagCorpus. Formato: projects/{project}/locations/{location}/ragCorpora/{rag_corpus}.
SIMILARITY_TOP_K: (facoltativo) il numero di contesti principali da recuperare.
VECTOR_DISTANCE_THRESHOLD: (facoltativo) vengono restituiti i contesti con una distanza vettoriale inferiore alla soglia.
USER: il tuo nome utente.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATION_METHOD"

Powershell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Una risposta corretta restituisce i contenuti generati con le citazioni.

Python


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

Per scoprire di più sui modelli di generazione supportati, consulta Modelli di IA generativa che supportano RAG.
Per scoprire di più sui modelli di incorporamento supportati, consulta la pagina Modelli di incorporamento.
Per scoprire di più sui modelli aperti, consulta Modelli aperti.
Per scoprire di più su RAG Engine, consulta la panoramica di RAG Engine.

API RAG Engine Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Elenco dei parametri

Parametri di gestione del corpus

Crea un corpus RAG

Corpo della richiesta

RagVectorDbConfig

Aggiorna un corpus RAG

Corpo della richiesta

Elenco corpora RAG

Ottieni un corpus RAG

Elimina un corpus RAG

Parametri di gestione dei file

Carica un file RAG

Corpo della richiesta

Importa file RAG

Recuperare un file RAG

Eliminare un file RAG

Recupero e previsione

Parametri di recupero

VertexRagStore

Parametri di previsione

Esempi di gestione dei corpus

Crea un esempio di corpus RAG

REST

curl

Powershell

Python

Aggiorna un esempio di corpus RAG

REST

curl

Powershell

Elenco di corpora RAG di esempio

REST

curl

Powershell

Python

Ottieni un esempio di corpus RAG

REST

curl

Powershell

Python

Elimina un esempio di corpus RAG

REST

curl

Powershell

Python

Esempi di gestione dei file

Carica un file RAG di esempio

REST

Python

Esempio di importazione di file RAG

REST

curl

Powershell

Python

Esempio di elenco di file RAG

REST

curl

Powershell

Python

Ottieni un esempio di file RAG

REST

curl

Powershell

Python

Elimina un esempio di file RAG

REST

curl

Powershell

Python

Query di recupero

REST

curl

Powershell

Python

Generazione

REST

curl

Powershell

Python

API RAG Engine

`RagVectorDbConfig`

`VertexRagStore`