Crea un datastore di ricerca

Per creare un datastore e importare i dati per la ricerca, vai alla sezione relativa all'origine che prevedi di utilizzare:

• Creare un datastore utilizzando i contenuti del sito web
• Importa da BigQuery
• Importa da Cloud Storage
• Sincronizzare da Google Drive
• Sincronizzazione da Gmail (anteprima pubblica)
• Sincronizzazione da Google Sites (Anteprima pubblica)
• Sincronizzazione da Google Calendar (anteprima pubblica)
• Sincronizzazione da Google Gruppi (Anteprima pubblica)
• Sincronizzare i dati delle persone (anteprima pubblica)
• Importa da Cloud SQL
• Importazione da Spanner (anteprima pubblica)
• Importa da Firestore
• Importa da Bigtable (Anteprima pubblica)
• Importazione da AlloyDB per PostgreSQL (anteprima pubblica)
• Carica dati JSON strutturati con l'API
• Creare un datastore utilizzando Terraform

Per sincronizzare i dati da un'origine dati di terze parti, consulta Connettere un'origine dati di terze parti.

Limitazioni

Se hai criteri dell'organizzazione per le chiavi di crittografia gestite dal cliente (CMEK), devi creare nuovi data store utilizzando l'API, non la console Google Cloud. La creazione di nuovi magazzini di dati utilizzando la console Google Cloud non va a buon fine se hai attivato i criteri dell'organizzazione CMEK. Per maggiori informazioni sul supporto delle chiavi CMEK per Vertex AI Search, consulta Chiavi di crittografia gestite dal cliente.

Creare un datastore utilizzando i contenuti del sito web

Utilizza la procedura seguente per creare un datastore e indicizzare i siti web.

Per utilizzare un datastore del sito web dopo averlo creato, devi collegarlo a un'app in cui sono attive le funzionalità Enterprise. Puoi attivare la versione Enterprise per un'appตอนquando la crei. Questa operazione comporta costi aggiuntivi. Consulta Creare un'app di ricerca e Informazioni sulle funzionalità avanzate.

Console

Per utilizzare la console Google Cloud per creare un datastore e indicizzare i siti web, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Nel menu di navigazione, fai clic su Datastore.

3. Fai clic su Crea datastore.

4. Nella pagina Origine, seleziona Contenuti dei siti web.

5. Scegli se attivare l'indicizzazione avanzata dei siti web per questo datastore. Questa opzione non può essere attivata o disattivata in un secondo momento.

   L'indicizzazione avanzata del sito web offre funzionalità aggiuntive come il riepilogo della ricerca, la ricerca con follow-up e le risposte estrattive. L'indicizzazione avanzata dei siti web comporta costi aggiuntivi e richiede la verifica della proprietà del dominio per tutti i siti web che indicizzi. Per ulteriori informazioni, consulta la sezione Indicizzazione avanzata dei siti web e Prezzi.

6. Nel campo Siti da includere, inserisci i pattern URL corrispondenti ai siti web che vuoi includere nel tuo datastore. Includi un pattern URL per riga, senza virgole. Ad esempio: www.example.com/docs/*

7. (Facoltativo) Nel campo Siti da escludere, inserisci i pattern di URL che vuoi escludere dal tuo datastore.

   Per conoscere il numero di pattern di URL che puoi includere o escludere, consulta Dati dei siti web.

8. Fai clic su Continua.

9. Seleziona una posizione per il tuo datastore. Per selezionare una località, l'indicizzazione avanzata dei siti web deve essere attivata.

10. Inserisci un nome per il tuo datastore.

11. Fai clic su Crea. Vertex AI Search crea il tuo datastore e lo visualizza nella pagina Datastore.

12. Per visualizzare le informazioni sul tuo datastore, fai clic sul nome del datastore nella colonna Nome. Viene visualizzata la pagina del tuo datastore.

    • Se hai attivato l'Indicizzazione avanzata dei siti web, viene visualizzato un avviso che ti chiede di verificare i domini nel tuo datastore.
    • Se hai un disavanzo di quota (il numero di pagine dei siti web che hai specificato supera la quota "Numero di documenti per progetto" per il tuo progetto), viene visualizzato un avviso aggiuntivo che ti chiede di eseguire l'upgrade della quota.

13. Per verificare i domini per i pattern URL nel tuo datastore, segui le istruzioni riportate nella pagina Verificare i domini dei siti web.

14. Per eseguire l'upgrade della quota:

    1. Fai clic su Esegui upgrade della quota. Viene visualizzata la pagina IAM e amministrazione della console Google Cloud.
    2. Segui le istruzioni riportate in Richiedere un limite di quota più alto nella documentazione di Google Cloud. La quota da aumentare è Numero di documenti nel servizio API Discovery Engine.
    3. Dopo aver inviato la richiesta di un limite di quota più elevato, torna alla pagina Agent Builder e fai clic su Datastore nel menu di navigazione.
    4. Fai clic sul nome del tuo datastore nella colonna Nome. La colonna Stato indica che l'indicizzazione è in corso per i siti web che hanno superato la quota. Quando la colonna Stato per un URL mostra Indicizzato, le funzionalità di indicizzazione avanzata del sito web sono disponibili per quell'URL o pattern URL.

    Per ulteriori informazioni, consulta la sezione Quota per l'indicizzazione delle pagine web nella pagina "Quote e limiti".

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importare siti web

from google.api_core.client_options import ClientOptions

from google.cloud import discoveryengine_v1 as discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# NOTE: Do not include http or https protocol in the URI pattern
# uri_pattern = "cloud.google.com/generative-ai-app-builder/docs/*"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.SiteSearchEngineServiceClient(
    client_options=client_options
)

# The full resource name of the data store
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}
site_search_engine = client.site_search_engine_path(
    project=project_id, location=location, data_store=data_store_id
)

# Target Site to index
target_site = discoveryengine.TargetSite(
    provided_uri_pattern=uri_pattern,
    # Options: INCLUDE, EXCLUDE
    type_=discoveryengine.TargetSite.Type.INCLUDE,
    exact_match=False,
)

# Make the request
operation = client.create_target_site(
    parent=site_search_engine,
    target_site=target_site,
)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.CreateTargetSiteMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Passaggi successivi

• Per collegare il datastore del tuo sito web a un'app, crea un'app con le funzionalità di Enterprise attivate e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importa da BigQuery

Puoi creare magazzini di dati dalle tabelle BigQuery in due modi:

• Importazione una tantum: importi i dati da una tabella BigQuery in un datastore. I dati nell'datastore non cambiano, a meno che non aggiorni manualmente i dati.

• Importazione periodica: importa i dati da una o più tabelle BigQuery e imposta una frequenza di sincronizzazione che determina la frequenza con cui i depositi di dati vengono aggiornati con i dati più recenti del set di dati BigQuery.

La tabella seguente mette a confronto i due modi in cui puoi importare i dati BigQuery nei datastore di Vertex AI Search.

Importazione una tantum	Importazione periodica
Generalmente disponibile (GA).	Anteprima pubblica.
I dati devono essere aggiornati manualmente.	I dati vengono aggiornati automaticamente ogni 1, 3 o 5 giorni. I dati non possono essere aggiornati manualmente.
Vertex AI Search crea un singolo datastore da una tabella in BigQuery.	Vertex AI Search crea un connettore di dati per un set di dati BigQuery e un datastore (chiamato data datastore entità) per ogni tabella specificata. Per ogni connettore di dati, le tabelle devono avere lo stesso tipo di dati (ad esempio, strutturati) e trovarsi nello stesso set di dati BigQuery.
I dati di più tabelle possono essere combinati in un unico datastore importando prima i dati di una tabella e poi altri dati da un'altra origine o tabella BigQuery.	Poiché l'importazione manuale dei dati non è supportata, i dati in un datastore delle entità possono provenire solo da una tabella BigQuery.
Il controllo dell'accesso all'origine dati è supportato.	Controllo dell'accesso all'origine dati non è supportato. I dati importati possono contenere controlli di accesso, ma questi controlli non verranno rispettati.
Puoi creare un datastore utilizzando la console Google Cloud o l'API.	Devi utilizzare la console per creare i connettori di dati e i relativi magazzini di dati delle entità.
Conformità a CMEK.	Non conforme a CMEK.

Importa una volta da BigQuery

Per importare i dati da una tabella BigQuery, segui questi passaggi per creare un datastore e importare i dati utilizzando la console Google Cloud o l'API.

Prima di importare i dati, consulta Preparare i dati per l'importazione.

Console

Per utilizzare la console Google Cloud per importare i dati da BigQuery:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona BigQuery.

5. Seleziona il tipo di dati che stai importando.

6. Fai clic su Una tantum.

7. Nel campo Percorso BigQuery, fai clic su Sfoglia, seleziona una tabella che hai preparato per l'importazione e poi fai clic su Seleziona. In alternativa, inserisci la posizione della tabella direttamente nel campo Percorso BigQuery.

8. Fai clic su Continua.

9. Se esegui l'importazione una tantum dei dati strutturati:

   1. Mappa i campi alle proprietà chiave.

   2. Se nello schema mancano campi importanti, utilizza Aggiungi nuovo campo per aggiungerli.

      Per saperne di più, consulta Informazioni sul rilevamento automatico e sull'editing.

   3. Fai clic su Continua.

10. Scegli una regione per il tuo datastore.

11. Inserisci un nome per il tuo datastore.

12. Fai clic su Crea.

13. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del datastore per visualizzarne i dettagli nella pagina Dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Importazione completata, l'importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere da alcuni minuti a diverse ore.

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da BigQuery, segui questi passaggi.

Nota: se vuoi specificare uno schema anziché lasciare che sia Vertex AI a rilevarlo automaticamente, segui i passaggi descritti in Fornire lo schema come oggetto JSON e poi inizia la procedura descritta di seguito dal passaggio 2.

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DATA_STORE_DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"]
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.
   • DATA_STORE_ID: l'ID del datastore di Vertex AI Search che vuoi creare. Questo ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DATA_STORE_DISPLAY_NAME: il nome visualizzato del datastore di ricerca Vertex AI che vuoi creare.

   (Facoltativo) Se carichi dati non strutturati e vuoi configurare l'analisi del testo o attivare l'aggregazione dei documenti per RAG, specifica l'oggetto documentProcessingConfig e includilo nella richiesta di creazione del datastore. Ti consigliamo di configurare un analizzatore OCR per i PDF se importi PDF scansionati. Per informazioni su come configurare le opzioni di analisi o suddivisione in blocchi, vedi Eseguire l'analisi e suddividere i documenti in blocchi.

2. Importa i dati da BigQuery.

   Se hai definito uno schema, assicurati che i dati siano conformi.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
   -d '{
     "bigquerySource": {
       "projectId": "PROJECT_ID",
       "datasetId":"DATASET_ID",
       "tableId": "TABLE_ID",
       "dataSchema": "DATA_SCHEMA",
       "aclEnabled": "BOOLEAN"
     },
     "reconciliationMode": "RECONCILIATION_MODE",
     "autoGenerateIds": "AUTO_GENERATE_IDS",
     "idField": "ID_FIELD",
     "errorConfig": {
       "gcsPrefix": "ERROR_DIRECTORY"
     }
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.
   • DATA_STORE_ID: l'ID dello datastore di Vertex AI Search.
   • DATASET_ID: l'ID del set di dati BigQuery.
   • TABLE_ID: l'ID della tabella BigQuery.
     • Se la tabella BigQuery non è in PROJECT_ID, devi concedere all'account di servizio service-<project number>@gcp-sa-discoveryengine.iam.gserviceaccount.com l'autorizzazione "Visualizzatore dei dati BigQuery" per la tabella BigQuery. Ad esempio, se importi una tabella BigQuery dal progetto di origine "123" al progetto di destinazione "456", concedi [e-mail] le autorizzazioni per la tabella BigQuery nel progetto "123".
   • DATA_SCHEMA: facoltativo. I valori sono document e custom. Il valore predefinito è document.
     • document: la tabella BigQuery da utilizzare deve essere conforme allo schema BigQuery predefinito fornito in Preparare i dati per l'importazione. Puoi definire autonomamente l'ID di ogni documento, inserendo tutti i dati nella stringa jsonData.
     • custom: qualsiasi schema di tabella BigQuery è accettato e Vertex AI Search genera automaticamente gli ID per ogni documento importato.
   • ERROR_DIRECTORY: facoltativo. Una directory Cloud Storage per le informazioni sugli errori relativi all'importazione, ad esempio gs://<your-gcs-bucket>/directory/import_errors. Google consiglia di lasciare vuoto questo campo per consentire a Vertex AI Search di creare automaticamente una directory temporanea.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da BigQuery al tuo datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo datastore e quelli non presenti in BigQuery vengono rimossi. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.

   • AUTO_GENERATE_IDS: facoltativo. Specifica se generare automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati in base a un hash del payload. Tieni presente che gli ID documento generati potrebbero non rimanere coerenti in più importazioni. Se generi automaticamente gli ID in più importazioni, Google consiglia vivamente di impostare reconciliationMode su FULL per mantenere ID documento coerenti.

     Specifica autoGenerateIds solo quando bigquerySource.dataSchema è impostato su custom. In caso contrario, viene restituito un errore INVALID_ARGUMENT. Se non specifichi autoGenerateIds o lo imposti su false, devi specificare idField. In caso contrario, l'importazione dei documenti non andrà a buon fine.

   • ID_FIELD: facoltativo. Specifica quali campi sono gli ID documento. Per i file di origine BigQuery, idField indica il nome della colonna nella tabella BigQuery che contiene gli ID documento.

     Specifica idField solo se: (1) bigquerySource.dataSchema è impostato su custom e (2) auto_generate_ids è impostato su false o non è specificato. In caso contrario, viene restituito un errore INVALID_ARGUMENT.

     Il valore del nome della colonna BigQuery deve essere di tipo stringa, deve essere compreso tra 1 e 63 caratteri e deve essere conforme a RFC-1034. In caso contrario, l'importazione dei documenti non andrà a buon fine.

C#

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API C# Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

using Google.Cloud.DiscoveryEngine.V1;
using Google.LongRunning;

public sealed partial class GeneratedDataStoreServiceClientSnippets
{
    /// <summary>Snippet for CreateDataStore</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void CreateDataStoreRequestObject()
    {
        // Create client
        DataStoreServiceClient dataStoreServiceClient = DataStoreServiceClient.Create();
        // Initialize request argument(s)
        CreateDataStoreRequest request = new CreateDataStoreRequest
        {
            ParentAsCollectionName = CollectionName.FromProjectLocationCollection("[PROJECT]", "[LOCATION]", "[COLLECTION]"),
            DataStore = new DataStore(),
            DataStoreId = "",
            CreateAdvancedSiteSearch = false,
            SkipDefaultSchemaCreation = false,
        };
        // Make the request
        Operation<DataStore, CreateDataStoreMetadata> response = dataStoreServiceClient.CreateDataStore(request);

        // Poll until the returned long-running operation is complete
        Operation<DataStore, CreateDataStoreMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataStore result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataStore, CreateDataStoreMetadata> retrievedResponse = dataStoreServiceClient.PollOnceCreateDataStore(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataStore retrievedResult = retrievedResponse.Result;
        }
    }
}

Importa documenti

using Google.Cloud.DiscoveryEngine.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDocumentServiceClientSnippets
{
    /// <summary>Snippet for ImportDocuments</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void ImportDocumentsRequestObject()
    {
        // Create client
        DocumentServiceClient documentServiceClient = DocumentServiceClient.Create();
        // Initialize request argument(s)
        ImportDocumentsRequest request = new ImportDocumentsRequest
        {
            ParentAsBranchName = BranchName.FromProjectLocationDataStoreBranch("[PROJECT]", "[LOCATION]", "[DATA_STORE]", "[BRANCH]"),
            InlineSource = new ImportDocumentsRequest.Types.InlineSource(),
            ErrorConfig = new ImportErrorConfig(),
            ReconciliationMode = ImportDocumentsRequest.Types.ReconciliationMode.Unspecified,
            UpdateMask = new FieldMask(),
            AutoGenerateIds = false,
            IdField = "",
        };
        // Make the request
        Operation<ImportDocumentsResponse, ImportDocumentsMetadata> response = documentServiceClient.ImportDocuments(request);

        // Poll until the returned long-running operation is complete
        Operation<ImportDocumentsResponse, ImportDocumentsMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        ImportDocumentsResponse result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<ImportDocumentsResponse, ImportDocumentsMetadata> retrievedResponse = documentServiceClient.PollOnceImportDocuments(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            ImportDocumentsResponse retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

package main

import (
	"context"

	discoveryengine "cloud.google.com/go/discoveryengine/apiv1"
	discoveryenginepb "cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := discoveryengine.NewDataStoreClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &discoveryenginepb.CreateDataStoreRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb#CreateDataStoreRequest.
	}
	op, err := c.CreateDataStore(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Importa documenti

package main

import (
	"context"

	discoveryengine "cloud.google.com/go/discoveryengine/apiv1"
	discoveryenginepb "cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := discoveryengine.NewDocumentClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &discoveryenginepb.ImportDocumentsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb#ImportDocumentsRequest.
	}
	op, err := c.ImportDocuments(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

import com.google.cloud.discoveryengine.v1.CollectionName;
import com.google.cloud.discoveryengine.v1.CreateDataStoreRequest;
import com.google.cloud.discoveryengine.v1.DataStore;
import com.google.cloud.discoveryengine.v1.DataStoreServiceClient;

public class SyncCreateDataStore {

  public static void main(String[] args) throws Exception {
    syncCreateDataStore();
  }

  public static void syncCreateDataStore() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataStoreServiceClient dataStoreServiceClient = DataStoreServiceClient.create()) {
      CreateDataStoreRequest request =
          CreateDataStoreRequest.newBuilder()
              .setParent(CollectionName.of("[PROJECT]", "[LOCATION]", "[COLLECTION]").toString())
              .setDataStore(DataStore.newBuilder().build())
              .setDataStoreId("dataStoreId929489618")
              .setCreateAdvancedSiteSearch(true)
              .setSkipDefaultSchemaCreation(true)
              .build();
      DataStore response = dataStoreServiceClient.createDataStoreAsync(request).get();
    }
  }
}

Importa documenti

import com.google.cloud.discoveryengine.v1.BranchName;
import com.google.cloud.discoveryengine.v1.DocumentServiceClient;
import com.google.cloud.discoveryengine.v1.ImportDocumentsRequest;
import com.google.cloud.discoveryengine.v1.ImportDocumentsResponse;
import com.google.cloud.discoveryengine.v1.ImportErrorConfig;
import com.google.protobuf.FieldMask;

public class SyncImportDocuments {

  public static void main(String[] args) throws Exception {
    syncImportDocuments();
  }

  public static void syncImportDocuments() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentServiceClient documentServiceClient = DocumentServiceClient.create()) {
      ImportDocumentsRequest request =
          ImportDocumentsRequest.newBuilder()
              .setParent(
                  BranchName.ofProjectLocationDataStoreBranchName(
                          "[PROJECT]", "[LOCATION]", "[DATA_STORE]", "[BRANCH]")
                      .toString())
              .setErrorConfig(ImportErrorConfig.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setAutoGenerateIds(true)
              .setIdField("idField1629396127")
              .build();
      ImportDocumentsResponse response = documentServiceClient.importDocumentsAsync(request).get();
    }
  }
}

Node.js

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The parent resource name, such as
 *  `projects/{project}/locations/{location}/collections/{collection}`.
 */
// const parent = 'abc123'
/**
 *  Required. The DataStore google.cloud.discoveryengine.v1.DataStore  to
 *  create.
 */
// const dataStore = {}
/**
 *  Required. The ID to use for the
 *  DataStore google.cloud.discoveryengine.v1.DataStore, which will become
 *  the final component of the
 *  DataStore google.cloud.discoveryengine.v1.DataStore's resource name.
 *  This field must conform to RFC-1034 (https://tools.ietf.org/html/rfc1034)
 *  standard with a length limit of 63 characters. Otherwise, an
 *  INVALID_ARGUMENT error is returned.
 */
// const dataStoreId = 'abc123'
/**
 *  A boolean flag indicating whether user want to directly create an advanced
 *  data store for site search.
 *  If the data store is not configured as site
 *  search (GENERIC vertical and PUBLIC_WEBSITE content_config), this flag will
 *  be ignored.
 */
// const createAdvancedSiteSearch = true
/**
 *  A boolean flag indicating whether to skip the default schema creation for
 *  the data store. Only enable this flag if you are certain that the default
 *  schema is incompatible with your use case.
 *  If set to true, you must manually create a schema for the data store before
 *  any documents can be ingested.
 *  This flag cannot be specified if `data_store.starting_schema` is specified.
 */
// const skipDefaultSchemaCreation = true

// Imports the Discoveryengine library
const {DataStoreServiceClient} = require('@google-cloud/discoveryengine').v1;

// Instantiates a client
const discoveryengineClient = new DataStoreServiceClient();

async function callCreateDataStore() {
  // Construct request
  const request = {
    parent,
    dataStore,
    dataStoreId,
  };

  // Run request
  const [operation] = await discoveryengineClient.createDataStore(request);
  const [response] = await operation.promise();
  console.log(response);
}

callCreateDataStore();

Importa documenti

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  The Inline source for the input content for documents.
 */
// const inlineSource = {}
/**
 *  Cloud Storage location for the input content.
 */
// const gcsSource = {}
/**
 *  BigQuery input source.
 */
// const bigquerySource = {}
/**
 *  FhirStore input source.
 */
// const fhirStoreSource = {}
/**
 *  Spanner input source.
 */
// const spannerSource = {}
/**
 *  Cloud SQL input source.
 */
// const cloudSqlSource = {}
/**
 *  Firestore input source.
 */
// const firestoreSource = {}
/**
 *  AlloyDB input source.
 */
// const alloyDbSource = {}
/**
 *  Cloud Bigtable input source.
 */
// const bigtableSource = {}
/**
 *  Required. The parent branch resource name, such as
 *  `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
 *  Requires create/update permission.
 */
// const parent = 'abc123'
/**
 *  The desired location of errors incurred during the Import.
 */
// const errorConfig = {}
/**
 *  The mode of reconciliation between existing documents and the documents to
 *  be imported. Defaults to
 *  ReconciliationMode.INCREMENTAL google.cloud.discoveryengine.v1.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL.
 */
// const reconciliationMode = {}
/**
 *  Indicates which fields in the provided imported documents to update. If
 *  not set, the default is to update all fields.
 */
// const updateMask = {}
/**
 *  Whether to automatically generate IDs for the documents if absent.
 *  If set to `true`,
 *  Document.id google.cloud.discoveryengine.v1.Document.id s are
 *  automatically generated based on the hash of the payload, where IDs may not
 *  be consistent during multiple imports. In which case
 *  ReconciliationMode.FULL google.cloud.discoveryengine.v1.ImportDocumentsRequest.ReconciliationMode.FULL 
 *  is highly recommended to avoid duplicate contents. If unset or set to
 *  `false`, Document.id google.cloud.discoveryengine.v1.Document.id s have
 *  to be specified using
 *  id_field google.cloud.discoveryengine.v1.ImportDocumentsRequest.id_field,
 *  otherwise, documents without IDs fail to be imported.
 *  Supported data sources:
 *  * GcsSource google.cloud.discoveryengine.v1.GcsSource.
 *  GcsSource.data_schema google.cloud.discoveryengine.v1.GcsSource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * BigQuerySource google.cloud.discoveryengine.v1.BigQuerySource.
 *  BigQuerySource.data_schema google.cloud.discoveryengine.v1.BigQuerySource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * SpannerSource google.cloud.discoveryengine.v1.SpannerSource.
 *  * CloudSqlSource google.cloud.discoveryengine.v1.CloudSqlSource.
 *  * FirestoreSource google.cloud.discoveryengine.v1.FirestoreSource.
 *  * BigtableSource google.cloud.discoveryengine.v1.BigtableSource.
 */
// const autoGenerateIds = true
/**
 *  The field indicates the ID field or column to be used as unique IDs of
 *  the documents.
 *  For GcsSource google.cloud.discoveryengine.v1.GcsSource  it is the key of
 *  the JSON field. For instance, `my_id` for JSON `{"my_id": "some_uuid"}`.
 *  For others, it may be the column name of the table where the unique ids are
 *  stored.
 *  The values of the JSON field or the table column are used as the
 *  Document.id google.cloud.discoveryengine.v1.Document.id s. The JSON field
 *  or the table column must be of string type, and the values must be set as
 *  valid strings conform to RFC-1034 (https://tools.ietf.org/html/rfc1034)
 *  with 1-63 characters. Otherwise, documents without valid IDs fail to be
 *  imported.
 *  Only set this field when
 *  auto_generate_ids google.cloud.discoveryengine.v1.ImportDocumentsRequest.auto_generate_ids 
 *  is unset or set as `false`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  If it is unset, a default value `_id` is used when importing from the
 *  allowed data sources.
 *  Supported data sources:
 *  * GcsSource google.cloud.discoveryengine.v1.GcsSource.
 *  GcsSource.data_schema google.cloud.discoveryengine.v1.GcsSource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * BigQuerySource google.cloud.discoveryengine.v1.BigQuerySource.
 *  BigQuerySource.data_schema google.cloud.discoveryengine.v1.BigQuerySource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * SpannerSource google.cloud.discoveryengine.v1.SpannerSource.
 *  * CloudSqlSource google.cloud.discoveryengine.v1.CloudSqlSource.
 *  * FirestoreSource google.cloud.discoveryengine.v1.FirestoreSource.
 *  * BigtableSource google.cloud.discoveryengine.v1.BigtableSource.
 */
// const idField = 'abc123'

// Imports the Discoveryengine library
const {DocumentServiceClient} = require('@google-cloud/discoveryengine').v1;

// Instantiates a client
const discoveryengineClient = new DocumentServiceClient();

async function callImportDocuments() {
  // Construct request
  const request = {
    parent,
  };

  // Run request
  const [operation] = await discoveryengineClient.importDocuments(request);
  const [response] = await operation.promise();
  console.log(response);
}

callImportDocuments();

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# bigquery_dataset = "YOUR_BIGQUERY_DATASET"
# bigquery_table = "YOUR_BIGQUERY_TABLE"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    bigquery_source=discoveryengine.BigQuerySource(
        project_id=project_id,
        dataset_id=bigquery_dataset,
        table_id=bigquery_table,
        data_schema="custom",
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Ruby

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Ruby Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

require "google/cloud/discovery_engine/v1"

##
# Snippet for the create_data_store call in the DataStoreService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DiscoveryEngine::V1::DataStoreService::Client#create_data_store.
#
def create_data_store
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DiscoveryEngine::V1::DataStoreService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DiscoveryEngine::V1::CreateDataStoreRequest.new

  # Call the create_data_store method.
  result = client.create_data_store request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Importa documenti

require "google/cloud/discovery_engine/v1"

##
# Snippet for the import_documents call in the DocumentService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DiscoveryEngine::V1::DocumentService::Client#import_documents.
#
def import_documents
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DiscoveryEngine::V1::DocumentService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DiscoveryEngine::V1::ImportDocumentsRequest.new

  # Call the import_documents method.
  result = client.import_documents request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Connettiti a BigQuery con sincronizzazione periodica

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

Prima di importare i dati, consulta Preparare i dati per l'importazione.

La procedura seguente descrive come creare un connettore dati che associ un set di dati BigQuery a un connettore dati Vertex AI Search e come specificare una tabella nel set di dati per ogni datastore che vuoi creare. I datastore che sono figli di connettori dati sono chiamati datastore di entità.

I dati del set di dati vengono sincronizzati periodicamente con i datastore delle entità. Puoi specificare la sincronizzazione giornaliera, ogni tre giorni o ogni cinque giorni.

Console

Per utilizzare la console Google Cloud per creare un connettore che sincronizzi periodicamente i dati da un set di dati BigQuery a Vertex AI Search, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Nel menu di navigazione, fai clic su Datastore.

3. Fai clic su Crea datastore.

4. Nella pagina Origine, seleziona BigQuery.

5. Seleziona il tipo di dati da importare.

6. Fai clic su Periodico.

7. Seleziona la Frequenza di sincronizzazione, ovvero la frequenza con cui vuoi che il connettore di ricerca Vertex AI si sincronizzi con il set di dati BigQuery. Puoi modificare la frequenza in un secondo momento.

8. Nel campo Percorso del set di dati BigQuery, fai clic su Sfoglia, seleziona il set di dati che contiene le tabelle che hai preparato per l'importazione. In alternativa, inserisci la posizione della tabella direttamente nel campo Percorso BigQuery. Il formato del percorso è projectname.datasetname.

9. Nel campo Tabelle da sincronizzare, fai clic su Sfoglia e seleziona una tabella che contiene i dati che ti interessano per il tuo datastore.

   Nota: assicurati che i dati nelle tabelle corrispondano al tipo di dati selezionato nel passaggio 5.
   Se si verifica una mancata corrispondenza, non lo saprai finché non si verifica una delle seguenti condizioni:

   • Vengono visualizzati errori quando il connettore tenta di importare i dati.
   • Vengono visualizzati risultati di ricerca imprevisti. Questo accade se il tipo selezionato era strutturato, ma avrebbe dovuto essere non strutturato o strutturato con metadati. I dati vengono importati, ma l'URL dei contenuti o i metadati non vengono riconosciuti e vengono trattati come stringa.

10. Se nel set di dati sono presenti altre tabelle che vuoi utilizzare per i depositi di dati, fai clic su Aggiungi tabella e specifica anche queste tabelle.

11. Fai clic su Continua.

12. Scegli una regione per il datastore, inserisci un nome per il connettore dati e fai clic su Crea.

    Ora hai creato un connettore dati che sincronizzerà periodicamente i dati con il set di dati BigQuery. Inoltre, hai creato uno o più magazzini di dati delle entità. Gli archivi dati hanno gli stessi nomi delle tabelle BigQuery.

13. Per controllare lo stato dell'importazione, vai alla pagina Data Store e fai clic sul nome del connettore dati per visualizzarne i dettagli nella pagina Dati > scheda Attività di importazione dei dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Riuscito, la prima importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere da alcuni minuti a diverse ore.

Dopo aver configurato l'origine dati e importato i dati per la prima volta, il datastore sincronizza i dati da questa origine con una frequenza selezionata durante la configurazione. La prima sincronizzazione avviene circa un'ora dopo la creazione del connettore dati. La sincronizzazione successiva avviene circa 24, 72 o 120 ore dopo.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importa da Cloud Storage

Puoi creare magazzini di dati dalle tabelle Cloud Storage in due modi:

• Importazione una tantum: importi i dati da una cartella o da un file Cloud Storage in un datastore. I dati nell'datastore non cambiano, a meno che non aggiorni manualmente i dati.

• Importazione periodica: importi i dati da un file o da una cartella Cloud Storage e imposti una frequenza di sincronizzazione che determina la frequenza con cui il data store viene aggiornato con i dati più recenti della posizione Cloud Storage.

La tabella seguente mette a confronto i due modi in cui puoi importare i dati di Cloud Storage nei datastore di Vertex AI Search.

Importazione una tantum	Importazione periodica
Generalmente disponibile (GA).	Anteprima pubblica.
I dati devono essere aggiornati manualmente.	I dati vengono aggiornati automaticamente ogni uno, tre o cinque giorni. I dati non possono essere aggiornati manualmente.
Vertex AI Search crea un singolo datastore da una cartella o un file in Cloud Storage.	Vertex AI Search crea un connettore di dati e lo associa a un datastore (chiamato datastore di entità) per il file o la cartella specificati. Ogni connettore di dati Cloud Storage può avere un singolo datastore delle entità.
I dati di più file, cartelle e bucket possono essere combinati in un unico datastore importando prima i dati da una posizione Cloud Storage e poi altri dati da un'altra posizione.	Poiché l'importazione manuale dei dati non è supportata, i dati in un entità possono essere ricavati solo da un file o una cartella Cloud Storage.
Il controllo dell'accesso all'origine dati è supportato. Per ulteriori informazioni, consulta Controllo dell'accesso alle origini dati.	Controllo dell'accesso all'origine dati non è supportato. I dati importati possono contenere controlli di accesso, ma questi controlli non verranno rispettati.
Puoi creare un datastore utilizzando la console Google Cloud o l'API.	Devi utilizzare la console per creare i connettori di dati e i relativi magazzini di dati delle entità.
Conformi a CMEK.	Non conforme a CMEK.

Importa una volta da Cloud Storage

Per importare i dati da Cloud Storage, segui questi passaggi per creare un datastore e importare i dati utilizzando la console Google Cloud o l'API.

Prima di importare i dati, consulta Preparare i dati per l'importazione.

Nota: l'importazione dei dati non è ricorsiva. In altre parole, se all'interno del bucket o della cartella specificata sono presenti cartelle, i file al loro interno non vengono importati.

Console

Per utilizzare la console per importare i dati da un bucket Cloud Storage, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Cloud Storage.

5. Nella sezione Seleziona una cartella o un file da importare, seleziona Cartella o File.

6. Fai clic su Sfoglia e scegli i dati che hai preparato per l'importazione, poi fai clic su Seleziona. In alternativa, inserisci la località direttamente nel campo gs://.

7. Seleziona il tipo di dati che stai importando.

8. Fai clic su Continua.

9. Se esegui l'importazione una tantum dei dati strutturati:

   1. Mappa i campi alle proprietà chiave.

   2. Se nello schema mancano campi importanti, utilizza Aggiungi nuovo campo per aggiungerli.

      Per saperne di più, consulta Informazioni sul rilevamento automatico e sull'editing.

   3. Fai clic su Continua.

10. Scegli una regione per il tuo datastore.

11. Scegli una regione per il tuo datastore.

12. Inserisci un nome per il tuo datastore.

13. (Facoltativo) Se hai selezionato documenti non strutturati, puoi selezionare le opzioni di analisi e suddivisione per i documenti. Per confrontare i parser, vedi Eseguire il parsing dei documenti. Per informazioni sul chunking, consulta Eseguire il chunking dei documenti per RAG.

    L'analisi del layout e l'analisi OCR possono comportare costi aggiuntivi. Consulta la pagina Prezzi delle funzionalità di DocAI.

    Per selezionare un parser, espandi Opzioni di elaborazione documenti e specifica le opzioni del parser che vuoi utilizzare.

14. Fai clic su Crea.

15. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del datastore per visualizzarne i dettagli nella pagina Dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Importazione completata, l'importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere diversi minuti o diverse ore.

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da Cloud Storage, segui questi passaggi.

Nota: se stai importando dati strutturati e vuoi specificare uno schema anziché lasciare che sia Vertex AI a rilevarlo automaticamente, segui i passaggi descritti in Fornire il proprio schema come oggetto JSON e poi inizia la procedura descritta nel passaggio 2.

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DATA_STORE_DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"],
     "contentConfig": "CONTENT_REQUIRED",
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.
   • DATA_STORE_ID: l'ID del datastore di Vertex AI Search che vuoi creare. Questo ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DATA_STORE_DISPLAY_NAME: il nome visualizzato del datastore di ricerca Vertex AI che vuoi creare.

   (Facoltativo) Per configurare l'analisi del documento o attivare il suddivisione in blocchi dei documenti per RAG, specifica l'oggetto documentProcessingConfig e includilo nella richiesta di creazione del datastore. Ti consigliamo di configurare un analizzatore OCR per i PDF se importi PDF scansionati. Per informazioni su come configurare le opzioni di analisi o suddivisione in blocchi, vedi Eseguire l'analisi e suddividere i documenti in blocchi.

2. Importa i dati da Cloud Storage.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
     -d '{
       "gcsSource": {
         "inputUris": ["INPUT_FILE_PATTERN_1", "INPUT_FILE_PATTERN_2"],
         "dataSchema": "DATA_SCHEMA",
       },
       "reconciliationMode": "RECONCILIATION_MODE",
       "autoGenerateIds": "AUTO_GENERATE_IDS",
       "idField": "ID_FIELD",
       "errorConfig": {
         "gcsPrefix": "ERROR_DIRECTORY"
       }
     }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.
   • DATA_STORE_ID: l'ID dello datastore di Vertex AI Search.

   • INPUT_FILE_PATTERN: un pattern di file in Cloud Storage contenente i tuoi documenti.

     Per i dati strutturati o per i dati non strutturati con metadati, gs://<your-gcs-bucket>/directory/object.jsonè un esempio di pattern del file di input e gs://<your-gcs-bucket>/directory/*.json è un esempio di corrispondenza del pattern con uno o più file.

     Per i documenti non strutturati, un esempio è gs://<your-gcs-bucket>/directory/*.pdf. Ogni file corrispondente al pattern diventa un documento.

     Se <your-gcs-bucket> non è in PROJECT_ID, devi concedere all'account di servizio service-<project number>@gcp-sa-discoveryengine.iam.gserviceaccount.com le autorizzazioni "Visualizzatore oggetti Storage" per il bucket Cloud Storage. Ad esempio, se importi un bucket Cloud Storage dal progetto di origine "123" al progetto di destinazione "456", concedi le autorizzazioni [e-mail] al bucket Cloud Storage nel progetto "123".

   • DATA_SCHEMA: facoltativo. I valori sono document, custom, csv e content. Il valore predefinito è document.

     • document: carica i dati non strutturati con i metadati per i documenti non strutturati. Ogni riga del file deve seguire uno dei seguenti formati. Puoi definire l'ID di ogni documento:

       • { "id": "<your-id>", "jsonData": "<JSON string>", "content": { "mimeType": "<application/pdf or text/html>", "uri": "gs://<your-gcs-bucket>/directory/filename.pdf" } }
       • { "id": "<your-id>", "structData": <JSON object>, "content": { "mimeType": "<application/pdf or text/html>", "uri": "gs://<your-gcs-bucket>/directory/filename.pdf" } }

     • custom: carica il file JSON per i documenti strutturati. I dati sono organizzati in base a uno schema. Puoi specificare lo schema; altrimenti viene rilevato automaticamente. Puoi inserire la stringa JSON del documento in un formato coerente direttamente in ogni riga e Vertex AI Search genera automaticamente gli ID per ogni documento importato.

     • content: carica i documenti non strutturati (PDF, HTML, DOC, TXT, PPTX). L'ID di ogni documento viene generato automaticamente come primi 128 bit di SHA256(GCS_URI) codificati come stringa esadecimale. Puoi specificare più pattern di file di input, a condizione che i file corrispondenti non superino il limite di 100.000 file.

     • csv: includi una riga di intestazione nel file CSV, con ogni intestazione mappata a un campo del documento. Specifica il percorso del file CSV utilizzando il campo inputUris.

   • ERROR_DIRECTORY: facoltativo. Una directory Cloud Storage per le informazioni sugli errori relativi all'importazione, ad esempio gs://<your-gcs-bucket>/directory/import_errors. Google consiglia di lasciare vuoto questo campo per consentire a Vertex AI Search di creare automaticamente una directory temporanea.

   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da Cloud Storage al tuo datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo datastore e quelli che non sono presenti in Cloud Storage vengono rimossi. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.

   • AUTO_GENERATE_IDS: facoltativo. Specifica se generare automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati in base a un hash del payload. Tieni presente che gli ID documento generati potrebbero non rimanere coerenti in più importazioni. Se generi automaticamente gli ID in più importazioni, Google consiglia vivamente di impostare reconciliationMode su FULL per mantenere gli ID documento coerenti.

     Specifica autoGenerateIds solo quando gcsSource.dataSchema è impostato su custom o csv. In caso contrario, viene restituito un errore INVALID_ARGUMENT. Se non specifichi autoGenerateIds o lo imposti su false, devi specificare idField. In caso contrario, l'importazione dei documenti non andrà a buon fine.

   • ID_FIELD: facoltativo. Specifica quali campi sono gli ID documento. Per i documenti di origine Cloud Storage, idField specifica il nome nei campi JSON che sono gli ID documento. Ad esempio, se {"my_id":"some_uuid"} è il campo ID documento in uno dei tuoi documenti, specifica "idField":"my_id". In questo modo, tutti i campi JSON con il nome "my_id" vengono identificati come ID documento.

     Specifica questo campo solo se: (1) gcsSource.dataSchema è impostato su custom o csv e (2) auto_generate_ids è impostato su false o non è specificato. In caso contrario, viene restituito un errore INVALID_ARGUMENT.

     Tieni presente che il valore del campo JSON di Cloud Storage deve essere di tipo stringa, deve essere compreso tra 1 e 63 caratteri e deve essere conforme a RFC-1034. In caso contrario, l'importazione dei documenti non andrà a buon fine.

     Tieni presente che il nome del campo JSON specificato da id_field deve essere di tipo stringa, deve essere compreso tra 1 e 63 caratteri e deve essere conforme allo standard RFC-1034. In caso contrario, l'importazione dei documenti non andrà a buon fine.

C#

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API C# Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

using Google.Cloud.DiscoveryEngine.V1;
using Google.LongRunning;

public sealed partial class GeneratedDataStoreServiceClientSnippets
{
    /// <summary>Snippet for CreateDataStore</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void CreateDataStoreRequestObject()
    {
        // Create client
        DataStoreServiceClient dataStoreServiceClient = DataStoreServiceClient.Create();
        // Initialize request argument(s)
        CreateDataStoreRequest request = new CreateDataStoreRequest
        {
            ParentAsCollectionName = CollectionName.FromProjectLocationCollection("[PROJECT]", "[LOCATION]", "[COLLECTION]"),
            DataStore = new DataStore(),
            DataStoreId = "",
            CreateAdvancedSiteSearch = false,
            SkipDefaultSchemaCreation = false,
        };
        // Make the request
        Operation<DataStore, CreateDataStoreMetadata> response = dataStoreServiceClient.CreateDataStore(request);

        // Poll until the returned long-running operation is complete
        Operation<DataStore, CreateDataStoreMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataStore result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataStore, CreateDataStoreMetadata> retrievedResponse = dataStoreServiceClient.PollOnceCreateDataStore(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataStore retrievedResult = retrievedResponse.Result;
        }
    }
}

Importa documenti

using Google.Cloud.DiscoveryEngine.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDocumentServiceClientSnippets
{
    /// <summary>Snippet for ImportDocuments</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void ImportDocumentsRequestObject()
    {
        // Create client
        DocumentServiceClient documentServiceClient = DocumentServiceClient.Create();
        // Initialize request argument(s)
        ImportDocumentsRequest request = new ImportDocumentsRequest
        {
            ParentAsBranchName = BranchName.FromProjectLocationDataStoreBranch("[PROJECT]", "[LOCATION]", "[DATA_STORE]", "[BRANCH]"),
            InlineSource = new ImportDocumentsRequest.Types.InlineSource(),
            ErrorConfig = new ImportErrorConfig(),
            ReconciliationMode = ImportDocumentsRequest.Types.ReconciliationMode.Unspecified,
            UpdateMask = new FieldMask(),
            AutoGenerateIds = false,
            IdField = "",
        };
        // Make the request
        Operation<ImportDocumentsResponse, ImportDocumentsMetadata> response = documentServiceClient.ImportDocuments(request);

        // Poll until the returned long-running operation is complete
        Operation<ImportDocumentsResponse, ImportDocumentsMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        ImportDocumentsResponse result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<ImportDocumentsResponse, ImportDocumentsMetadata> retrievedResponse = documentServiceClient.PollOnceImportDocuments(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            ImportDocumentsResponse retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

package main

import (
	"context"

	discoveryengine "cloud.google.com/go/discoveryengine/apiv1"
	discoveryenginepb "cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := discoveryengine.NewDataStoreClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &discoveryenginepb.CreateDataStoreRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb#CreateDataStoreRequest.
	}
	op, err := c.CreateDataStore(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Importa documenti

package main

import (
	"context"

	discoveryengine "cloud.google.com/go/discoveryengine/apiv1"
	discoveryenginepb "cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := discoveryengine.NewDocumentClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &discoveryenginepb.ImportDocumentsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/discoveryengine/apiv1/discoveryenginepb#ImportDocumentsRequest.
	}
	op, err := c.ImportDocuments(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

import com.google.cloud.discoveryengine.v1.CollectionName;
import com.google.cloud.discoveryengine.v1.CreateDataStoreRequest;
import com.google.cloud.discoveryengine.v1.DataStore;
import com.google.cloud.discoveryengine.v1.DataStoreServiceClient;

public class SyncCreateDataStore {

  public static void main(String[] args) throws Exception {
    syncCreateDataStore();
  }

  public static void syncCreateDataStore() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataStoreServiceClient dataStoreServiceClient = DataStoreServiceClient.create()) {
      CreateDataStoreRequest request =
          CreateDataStoreRequest.newBuilder()
              .setParent(CollectionName.of("[PROJECT]", "[LOCATION]", "[COLLECTION]").toString())
              .setDataStore(DataStore.newBuilder().build())
              .setDataStoreId("dataStoreId929489618")
              .setCreateAdvancedSiteSearch(true)
              .setSkipDefaultSchemaCreation(true)
              .build();
      DataStore response = dataStoreServiceClient.createDataStoreAsync(request).get();
    }
  }
}

Importa documenti

import com.google.cloud.discoveryengine.v1.BranchName;
import com.google.cloud.discoveryengine.v1.DocumentServiceClient;
import com.google.cloud.discoveryengine.v1.ImportDocumentsRequest;
import com.google.cloud.discoveryengine.v1.ImportDocumentsResponse;
import com.google.cloud.discoveryengine.v1.ImportErrorConfig;
import com.google.protobuf.FieldMask;

public class SyncImportDocuments {

  public static void main(String[] args) throws Exception {
    syncImportDocuments();
  }

  public static void syncImportDocuments() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DocumentServiceClient documentServiceClient = DocumentServiceClient.create()) {
      ImportDocumentsRequest request =
          ImportDocumentsRequest.newBuilder()
              .setParent(
                  BranchName.ofProjectLocationDataStoreBranchName(
                          "[PROJECT]", "[LOCATION]", "[DATA_STORE]", "[BRANCH]")
                      .toString())
              .setErrorConfig(ImportErrorConfig.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setAutoGenerateIds(true)
              .setIdField("idField1629396127")
              .build();
      ImportDocumentsResponse response = documentServiceClient.importDocumentsAsync(request).get();
    }
  }
}

Node.js

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The parent resource name, such as
 *  `projects/{project}/locations/{location}/collections/{collection}`.
 */
// const parent = 'abc123'
/**
 *  Required. The DataStore google.cloud.discoveryengine.v1.DataStore  to
 *  create.
 */
// const dataStore = {}
/**
 *  Required. The ID to use for the
 *  DataStore google.cloud.discoveryengine.v1.DataStore, which will become
 *  the final component of the
 *  DataStore google.cloud.discoveryengine.v1.DataStore's resource name.
 *  This field must conform to RFC-1034 (https://tools.ietf.org/html/rfc1034)
 *  standard with a length limit of 63 characters. Otherwise, an
 *  INVALID_ARGUMENT error is returned.
 */
// const dataStoreId = 'abc123'
/**
 *  A boolean flag indicating whether user want to directly create an advanced
 *  data store for site search.
 *  If the data store is not configured as site
 *  search (GENERIC vertical and PUBLIC_WEBSITE content_config), this flag will
 *  be ignored.
 */
// const createAdvancedSiteSearch = true
/**
 *  A boolean flag indicating whether to skip the default schema creation for
 *  the data store. Only enable this flag if you are certain that the default
 *  schema is incompatible with your use case.
 *  If set to true, you must manually create a schema for the data store before
 *  any documents can be ingested.
 *  This flag cannot be specified if `data_store.starting_schema` is specified.
 */
// const skipDefaultSchemaCreation = true

// Imports the Discoveryengine library
const {DataStoreServiceClient} = require('@google-cloud/discoveryengine').v1;

// Instantiates a client
const discoveryengineClient = new DataStoreServiceClient();

async function callCreateDataStore() {
  // Construct request
  const request = {
    parent,
    dataStore,
    dataStoreId,
  };

  // Run request
  const [operation] = await discoveryengineClient.createDataStore(request);
  const [response] = await operation.promise();
  console.log(response);
}

callCreateDataStore();

Importa documenti

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  The Inline source for the input content for documents.
 */
// const inlineSource = {}
/**
 *  Cloud Storage location for the input content.
 */
// const gcsSource = {}
/**
 *  BigQuery input source.
 */
// const bigquerySource = {}
/**
 *  FhirStore input source.
 */
// const fhirStoreSource = {}
/**
 *  Spanner input source.
 */
// const spannerSource = {}
/**
 *  Cloud SQL input source.
 */
// const cloudSqlSource = {}
/**
 *  Firestore input source.
 */
// const firestoreSource = {}
/**
 *  AlloyDB input source.
 */
// const alloyDbSource = {}
/**
 *  Cloud Bigtable input source.
 */
// const bigtableSource = {}
/**
 *  Required. The parent branch resource name, such as
 *  `projects/{project}/locations/{location}/collections/{collection}/dataStores/{data_store}/branches/{branch}`.
 *  Requires create/update permission.
 */
// const parent = 'abc123'
/**
 *  The desired location of errors incurred during the Import.
 */
// const errorConfig = {}
/**
 *  The mode of reconciliation between existing documents and the documents to
 *  be imported. Defaults to
 *  ReconciliationMode.INCREMENTAL google.cloud.discoveryengine.v1.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL.
 */
// const reconciliationMode = {}
/**
 *  Indicates which fields in the provided imported documents to update. If
 *  not set, the default is to update all fields.
 */
// const updateMask = {}
/**
 *  Whether to automatically generate IDs for the documents if absent.
 *  If set to `true`,
 *  Document.id google.cloud.discoveryengine.v1.Document.id s are
 *  automatically generated based on the hash of the payload, where IDs may not
 *  be consistent during multiple imports. In which case
 *  ReconciliationMode.FULL google.cloud.discoveryengine.v1.ImportDocumentsRequest.ReconciliationMode.FULL 
 *  is highly recommended to avoid duplicate contents. If unset or set to
 *  `false`, Document.id google.cloud.discoveryengine.v1.Document.id s have
 *  to be specified using
 *  id_field google.cloud.discoveryengine.v1.ImportDocumentsRequest.id_field,
 *  otherwise, documents without IDs fail to be imported.
 *  Supported data sources:
 *  * GcsSource google.cloud.discoveryengine.v1.GcsSource.
 *  GcsSource.data_schema google.cloud.discoveryengine.v1.GcsSource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * BigQuerySource google.cloud.discoveryengine.v1.BigQuerySource.
 *  BigQuerySource.data_schema google.cloud.discoveryengine.v1.BigQuerySource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * SpannerSource google.cloud.discoveryengine.v1.SpannerSource.
 *  * CloudSqlSource google.cloud.discoveryengine.v1.CloudSqlSource.
 *  * FirestoreSource google.cloud.discoveryengine.v1.FirestoreSource.
 *  * BigtableSource google.cloud.discoveryengine.v1.BigtableSource.
 */
// const autoGenerateIds = true
/**
 *  The field indicates the ID field or column to be used as unique IDs of
 *  the documents.
 *  For GcsSource google.cloud.discoveryengine.v1.GcsSource  it is the key of
 *  the JSON field. For instance, `my_id` for JSON `{"my_id": "some_uuid"}`.
 *  For others, it may be the column name of the table where the unique ids are
 *  stored.
 *  The values of the JSON field or the table column are used as the
 *  Document.id google.cloud.discoveryengine.v1.Document.id s. The JSON field
 *  or the table column must be of string type, and the values must be set as
 *  valid strings conform to RFC-1034 (https://tools.ietf.org/html/rfc1034)
 *  with 1-63 characters. Otherwise, documents without valid IDs fail to be
 *  imported.
 *  Only set this field when
 *  auto_generate_ids google.cloud.discoveryengine.v1.ImportDocumentsRequest.auto_generate_ids 
 *  is unset or set as `false`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  If it is unset, a default value `_id` is used when importing from the
 *  allowed data sources.
 *  Supported data sources:
 *  * GcsSource google.cloud.discoveryengine.v1.GcsSource.
 *  GcsSource.data_schema google.cloud.discoveryengine.v1.GcsSource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * BigQuerySource google.cloud.discoveryengine.v1.BigQuerySource.
 *  BigQuerySource.data_schema google.cloud.discoveryengine.v1.BigQuerySource.data_schema 
 *  must be `custom` or `csv`. Otherwise, an INVALID_ARGUMENT error is thrown.
 *  * SpannerSource google.cloud.discoveryengine.v1.SpannerSource.
 *  * CloudSqlSource google.cloud.discoveryengine.v1.CloudSqlSource.
 *  * FirestoreSource google.cloud.discoveryengine.v1.FirestoreSource.
 *  * BigtableSource google.cloud.discoveryengine.v1.BigtableSource.
 */
// const idField = 'abc123'

// Imports the Discoveryengine library
const {DocumentServiceClient} = require('@google-cloud/discoveryengine').v1;

// Instantiates a client
const discoveryengineClient = new DocumentServiceClient();

async function callImportDocuments() {
  // Construct request
  const request = {
    parent,
  };

  // Run request
  const [operation] = await discoveryengineClient.importDocuments(request);
  const [response] = await operation.promise();
  console.log(response);
}

callImportDocuments();

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"

# Examples:
# - Unstructured documents
#   - `gs://bucket/directory/file.pdf`
#   - `gs://bucket/directory/*.pdf`
# - Unstructured documents with JSONL Metadata
#   - `gs://bucket/directory/file.json`
# - Unstructured documents with CSV Metadata
#   - `gs://bucket/directory/file.csv`
# gcs_uri = "YOUR_GCS_PATH"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    gcs_source=discoveryengine.GcsSource(
        # Multiple URIs are supported
        input_uris=[gcs_uri],
        # Options:
        # - `content` - Unstructured documents (PDF, HTML, DOC, TXT, PPTX)
        # - `custom` - Unstructured documents with custom JSONL metadata
        # - `document` - Structured documents in the discoveryengine.Document format.
        # - `csv` - Unstructured documents with CSV metadata
        data_schema="content",
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Ruby

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Ruby Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

require "google/cloud/discovery_engine/v1"

##
# Snippet for the create_data_store call in the DataStoreService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DiscoveryEngine::V1::DataStoreService::Client#create_data_store.
#
def create_data_store
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DiscoveryEngine::V1::DataStoreService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DiscoveryEngine::V1::CreateDataStoreRequest.new

  # Call the create_data_store method.
  result = client.create_data_store request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Importa documenti

require "google/cloud/discovery_engine/v1"

##
# Snippet for the import_documents call in the DocumentService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::DiscoveryEngine::V1::DocumentService::Client#import_documents.
#
def import_documents
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::DiscoveryEngine::V1::DocumentService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::DiscoveryEngine::V1::ImportDocumentsRequest.new

  # Call the import_documents method.
  result = client.import_documents request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

Connettiti a Cloud Storage con la sincronizzazione periodica

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

Prima di importare i dati, consulta Preparare i dati per l'importazione.

La procedura seguente descrive come creare un connettore dati che associ una posizione Cloud Storage a un connettore dati Vertex AI Search e come specificare una cartella o un file in quella posizione per il datastore che vuoi creare. I datastore figli dei connettori dati sono chiamati datastore entità.

I dati vengono sincronizzati periodicamente con il datastore delle entità. Puoi specificare la sincronizzazione giornaliera, ogni tre giorni o ogni cinque giorni.

Console

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Crea datastore.

4. Nella pagina Origine, seleziona Cloud Storage.

5. Seleziona il tipo di dati che stai importando.

6. Fai clic su Periodico.

7. Seleziona la frequenza di sincronizzazione, ovvero la frequenza con cui vuoi che il connettore di ricerca Vertex AI si sincronizzi con la posizione di Cloud Storage. Puoi modificare la frequenza in un secondo momento.

8. Nella sezione Seleziona una cartella o un file da importare, seleziona Cartella o File.

9. Fai clic su Sfoglia e scegli i dati che hai preparato per l'importazione, poi fai clic su Seleziona. In alternativa, inserisci la località direttamente nel campo gs://.

10. Fai clic su Continua.

11. Scegli una regione per il connettore dati.

12. Inserisci un nome per il connettore dati.

13. (Facoltativo) Se hai selezionato documenti non strutturati, puoi selezionare le opzioni di analisi e suddivisione per i documenti. Per confrontare i parser, vedi Eseguire il parsing dei documenti. Per informazioni sul chunking, consulta Eseguire il chunking dei documenti per RAG.

    L'analisi del layout e l'analisi OCR possono comportare costi aggiuntivi. Consulta la pagina Prezzi delle funzionalità di DocAI.

    Per selezionare un parser, espandi Opzioni di elaborazione documenti e specifica le opzioni del parser che vuoi utilizzare.

14. Fai clic su Crea.

    Ora hai creato un connettore dati che sincronizzerà periodicamente i dati con la posizione Cloud Storage. Hai anche creato un datastore di entità denominato gcs_store.

15. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del connettore dati per visualizzarne i dettagli nella pagina Dati.

    Scheda Attività di importazione dati. Quando la colonna dello stato nella scheda Attività di importazione dei dati passa da In corso a Riuscito, la prima importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere da alcuni minuti a diverse ore.

Dopo aver configurato l'origine dati e importato i dati per la prima volta, i dati vengono sincronizzati da questa origine con una frequenza selezionata durante la configurazione. La prima sincronizzazione avviene circa un'ora dopo la creazione del connettore dati. La sincronizzazione successiva avviene circa 24, 72 o 120 ore dopo.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Connettiti a Google Drive

Per eseguire ricerche nei dati di Google Drive, segui questi passaggi per creare un connettore utilizzando la console Google Cloud.

Prima di iniziare:

• Devi aver eseguito l'accesso alla console Google Cloud con lo stesso account che utilizzi per l'istanza di Google Drive che intendi collegare. Vertex AI Search utilizza il tuo ID cliente Google Workspace per connettersi a Google Drive.

• Configura controllo dell'accesso per Google Drive. Per informazioni sulla configurazione del controllo dell'accesso dell'accesso, consulta Utilizzare il controllo dell'accesso alle origini dati.

• La ricerca avanzata di Google Drive è in anteprima privata. Questa funzionalità è un prerequisito per l'utilizzo del riassunto della ricerca e della ricerca con domande aggiuntive con un datastore di Google Drive. Per utilizzare questa funzionalità, segui la procedura descritta in Utilizzare l'indicizzazione avanzata di Drive.

Console

Per utilizzare la console per rendere disponibili per la ricerca i dati di Google Drive, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Google Drive.

5. Scegli una regione per il tuo datastore.

6. Inserisci un nome per il tuo datastore. . Fai clic su Crea.

Utilizzare l'indicizzazione avanzata delle unità (anteprima privata)

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

L'indicizzazione avanzata delle unità è in anteprima privata.

Segui questa procedura se prevedi di utilizzare Google Drive con la sintesi della ricerca e la ricerca con follow-up.

Prima di iniziare:

• Per attivare l'indicizzazione avanzata di Drive, devi essere un super amministratore di Google Workspace. Questo perché, con l'indicizzazione avanzata delle unità, Vertex AI Search indicizza i dati di Google Drive.
• Per utilizzare questa funzionalità, devi essere aggiunto alla lista consentita.

Console

Per utilizzare la console per creare un datastore di Google Drive con l'indicizzazione avanzata di Google Drive:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Google Drive.

5. Seleziona Indicizzazione avanzata delle unità.

6. Inserisci il tuo indirizzo email Google Workspace.

7. Nella sezione Configurare la delega a livello di dominio, esamina le istruzioni e prendi nota dell'ID client dell'account di servizio fornito nel passaggio 4 della sezione.

8. Configura la delega a livello di dominio:

   1. Vai alla pagina Delega a livello di dominio della Console di amministrazione Google Workspace e accedi con il tuo account super amministratore.
   2. Fai clic su Aggiungi nuovo.
   3. Inserisci l'ID client dell'account di servizio che hai annotato. Questo ID è fornito nelle istruzioni della console Agent Builder nella sezione Configura la delega a livello di dominio.

   4. Inserisci i seguenti ambiti OAuth.

      https://www.googleapis.com/auth/drive.readonly,
      https://www.googleapis.com/auth/admin.directory.user.readonly,
      https://www.googleapis.com/auth/admin.directory.group.readonly,
      https://www.googleapis.com/auth/admin.directory.domain.readonly,
      https://www.googleapis.com/auth/admin.reports.audit.readonly
      

   5. Fai clic su Autorizza.

9. Nella console di Agent Builder, fai clic su Continua.

10. Scegli una regione per il tuo datastore.

11. Inserisci un nome per il tuo datastore.

12. Fai clic su Crea. A seconda delle dimensioni dei dati, l'importazione può richiedere da alcuni minuti a diverse ore. Attendi almeno un'ora prima di utilizzare il tuo datastore per la ricerca.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Collegarti a Gmail

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

Per eseguire ricerche nei dati di Gmail, segui questi passaggi per creare un datastore e importare i dati utilizzando la console Google Cloud.

Prima di iniziare:

• Devi aver eseguito l'accesso alla console Google Cloud con lo stesso account utilizzato per l'istanza Google Workspace che intendi collegare. Vertex AI Search utilizza il tuo ID cliente Google Workspace per connettersi a Gmail.

• Configura controllo dell'accesso per Gmail. Per informazioni sulla configurazione del controllo dell'accesso dell'accesso, consulta Utilizzare il controllo dell'accesso alle origini dati.

Console

Per utilizzare la console per rendere i dati di Gmail disponibili per la ricerca, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Google Gmail.

5. Scegli una regione per il tuo datastore.

6. Inserisci un nome per il tuo datastore.

7. Fai clic su Crea.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Connettersi a Google Sites

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

Per eseguire ricerche nei dati di Google Sites, segui questi passaggi per creare un connettore utilizzando la console Google Cloud.

Prima di iniziare:

• Devi aver eseguito l'accesso alla console Google Cloud con lo stesso account utilizzato per l'istanza Google Workspace che intendi collegare. Vertex AI Search utilizza il tuo ID cliente Google Workspace per connettersi a Google Sites.

• Configura controllo dell'accesso per Google Sites. Per informazioni sulla configurazione del controllo dell'accesso dell'accesso, consulta Utilizzare il controllo dell'accesso alle origini dati.

Console

Per utilizzare la console per rendere disponibili per la ricerca i dati di Google Sites, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Google Sites.

5. Scegli una regione per il tuo datastore.

6. Inserisci un nome per il tuo datastore.

7. Fai clic su Crea.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Connessione a Google Calendar

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

Per eseguire ricerche nei dati di Google Calendar, segui questi passaggi per creare un connettore utilizzando la console Google Cloud.

Prima di iniziare:

• Devi aver eseguito l'accesso alla console Google Cloud con lo stesso account utilizzato per l'istanza Google Workspace che intendi collegare. Vertex AI Search utilizza il tuo ID cliente Google Workspace per connettersi a Google Calendar.

• Configura controllo dell'accesso per Google Calendar. Per informazioni sulla configurazione del controllo dell'accesso dell'accesso, consulta Utilizzare il controllo dell'accesso alle origini dati.

Console

Per utilizzare la console per rendere disponibili per la ricerca i dati di Google Calendar, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Google Calendar.

5. Scegli una regione per il tuo datastore.

6. Inserisci un nome per il tuo datastore.

7. Fai clic su Crea.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Connettiti a Google Gruppi

Nota: questa funzionalità è un'offerta in anteprima, soggetta ai "Termini dell'offerta pre-GA" dei Termini di servizio specifici per Google Cloud. I prodotti e le funzionalità pre-GA potrebbero avere supporto limitato e le modifiche ai prodotti e alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio. Inoltre, utilizzando questa funzionalità, accetti i Termini e condizioni di Anteprima dell'IA generativa ("Termini di anteprima"). Per questa funzionalità, puoi trattare i dati personali come descritto nell'Addendum per il trattamento dei dati Cloud, in conformità alle limitazioni e alle obbligazioni applicabili del Contratto (come definite nei Termini di anteprima).

Per eseguire ricerche nei dati di Google Gruppi, segui questi passaggi per creare un connettore utilizzando la console Google Cloud.

Prima di iniziare:

• Devi aver eseguito l'accesso alla console Google Cloud con lo stesso account utilizzato per l'istanza Google Workspace che intendi collegare. Vertex AI Search utilizza il tuo ID cliente Google Workspace per connettersi a Google Gruppi.

• Configura controllo dell'accesso per Google Gruppi. Per informazioni sulla configurazione del controllo dell'accesso dell'accesso, consulta Utilizzare il controllo dell'accesso alle origini dati.

Console

Per utilizzare la console per rendere disponibili per la ricerca i dati di Google Gruppi, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Gruppi Google.

5. Scegli una regione per il tuo datastore.

6. Inserisci un nome per il tuo datastore.

7. Fai clic su Crea. A seconda delle dimensioni dei dati, l'importazione può richiedere da alcuni minuti a diverse ore. Attendi almeno un'ora prima di utilizzare il tuo datastore per la ricerca.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Sincronizzare i dati delle persone da Google Workspace

Puoi configurare la ricerca delle persone per i tuoi team di lavoro sincronizzando i dati delle persone da Google Workspace. Questi dati vengono sincronizzati continuamente con Vertex AI Search dopo aver creato il tuo datastore.

Le persone della tua directory vengono visualizzate nei risultati di ricerca come schede che mostrano le informazioni del profilo disponibili di una persona, ad esempio nome, indirizzo email, organizzazione e immagine del profilo. Puoi fare clic su una scheda per visualizzare la pagina dei dettagli della persona.

Prerequisiti

1. Determina con quale provider di identità gli utenti accederanno alla tua app. Se utilizzi un provider di identità di terze parti, un amministratore deve federarlo con Google Workspace. La pianificazione e la configurazione della federazione possono richiedere molto tempo. Per ulteriori informazioni, consulta Utilizzare il controllo accessi delle origini dati.

2. Un amministratore di Google Workspace deve attivare la ricerca di persone nei dati di Google Workspace. Ecco come fare:

   1. Accedi alla Console di amministrazione Google con un account amministratore.
   2. Nella Console di amministrazione, vai a Directory > Impostazioni directory.
   3. Attiva Condivisione dei contatti.

3. Accedi alla console Google Cloud con lo stesso account da cui prevedi di collegare Google Workspace.

4. Connettiti al tuo provider di identità seguendo i passaggi descritti in Connetti il tuo provider di identità e specifica Identità Google come provider.

Per informazioni sulla directory di Google Workspace, vedi Panoramica: configurare e gestire la directory nella documentazione di Google Workspace.

Crea un datastore per la ricerca di persone

Console

Per utilizzare la console per importare i dati delle persone:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Crea datastore.

4. Nella pagina Origine, seleziona Ricerca di persone.

5. Scegli una regione per il tuo datastore.

6. Inserisci un nome per il tuo datastore.

7. Fai clic su Crea. A seconda delle dimensioni dei dati, la sincronizzazione può richiedere da alcuni minuti a diverse ore.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importa da Cloud SQL

Per importare i dati da Cloud SQL, segui questi passaggi per configurare l'accesso a Cloud SQL, creare un datastore e importare i dati.

Configurare l'accesso al bucket di staging per le istanze Cloud SQL

Durante l'importazione dei dati da Cloud SQL, i dati vengono prima trasferiti in un bucket Cloud Storage. Segui questi passaggi per concedere a un'istanza Cloud SQL l'accesso ai bucket Cloud Storage.

1. Nella console Google Cloud, vai alla pagina SQL.

   SQL

2. Fai clic sull'istanza Cloud SQL da cui vuoi eseguire l'importazione.

3. Copia l'identificatore dell'account di servizio dell'istanza, che ha il formato di un indirizzo email, ad [e-mail].

4. Vai alla pagina IAM e amministrazione.

   IAM e amministrazione

5. Fai clic su Concedi accesso.

6. In Nuove entità, inserisci l'identificatore dell'account di servizio dell'istanza e seleziona il ruolo Cloud Storage > Amministratore Storage.

7. Fai clic su Salva.

Successivo:

• Se i tuoi dati Cloud SQL si trovano nello stesso progetto di Vertex AI Search: vai a Importare i dati da Cloud SQL.

• Se i dati Cloud SQL si trovano in un progetto diverso da quello di Vertex AI Search: vai a Configurare l'accesso a Cloud SQL da un progetto diverso.

Configurare l'accesso a Cloud SQL da un progetto diverso

Per concedere a Vertex AI Search l'accesso ai dati Cloud SQL di un progetto diverso:

1. Sostituisci la seguente variabile PROJECT_NUMBER con il numero del progetto Vertex AI Search, quindi copia i contenuti del blocco di codice. Questo è l'identificatore del tuo account di servizio Vertex AI Search:

   [e-mail]`
   

2. Vai alla pagina IAM e amministrazione.

   IAM e amministrazione

3. Passa al tuo progetto Cloud SQL nella pagina IAM e amministrazione e fai clic su Concedi l'accesso.

4. In Nuove entità, inserisci l'identificatore dell'account di servizio e seleziona il ruolo Cloud SQL > Visualizzatore Cloud SQL.

5. Fai clic su Salva.

Poi, vai a Importare dati da Cloud SQL.

Importare dati da Cloud SQL

Console

Per utilizzare la console per importare i dati da Cloud SQL, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Cloud SQL.

5. Specifica l'ID progetto, l'ID istanza, l'ID database e l'ID tabella dei dati che intendi importare.

6. Fai clic su Sfoglia e scegli una posizione intermedia di Cloud Storage in cui esportare i dati, quindi fai clic su Seleziona. In alternativa, inserisci la località direttamente nel campo gs://.

7. Seleziona se attivare l'esportazione serverless. L'esportazione serverless comporta costi aggiuntivi. Per informazioni sull'esportazione serverless, consulta Minimizzare l'impatto delle esportazioni sulle prestazioni nella documentazione di Cloud SQL.

8. Fai clic su Continua.

9. Scegli una regione per il tuo datastore.

10. Inserisci un nome per il tuo datastore.

11. Fai clic su Crea.

12. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del datastore per visualizzarne i dettagli nella pagina Dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Importazione completata, l'importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere diversi minuti o diverse ore.

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da Cloud SQL:

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1alpha/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"],
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo messaggio potrebbe essere visualizzato nella console Google Cloud.

2. Importa i dati da Cloud SQL.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
     -d '{
       "cloudSqlSource": {
         "projectId": "SQL_PROJECT_ID",
         "instanceId": "INSTANCE_ID",
         "databaseId": "DATABASE_ID",
         "tableId": "TABLE_ID",
         "gcsStagingDir": "STAGING_DIRECTORY"
       },
       "reconciliationMode": "RECONCILIATION_MODE",
       "autoGenerateIds": "AUTO_GENERATE_IDS",
       "idField": "ID_FIELD",
     }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Vertex AI Search.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • SQL_PROJECT_ID: l'ID del tuo progetto Cloud SQL.
   • INSTANCE_ID: l'ID dell'istanza Cloud SQL.
   • DATABASE_ID: l'ID del tuo database Cloud SQL.
   • TABLE_ID: l'ID della tabella Cloud SQL.
   • STAGING_DIRECTORY: facoltativo. Una directory Cloud Storage, ad esempio gs://<your-gcs-bucket>/directory/import_errors.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da Cloud SQL al tuo datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo data store e quelli che non sono presenti in Cloud SQL vengono rimossi dal tuo datastore. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# sql_project_id = "YOUR_SQL_PROJECT_ID"
# sql_instance_id = "YOUR_SQL_INSTANCE_ID"
# sql_database_id = "YOUR_SQL_DATABASE_ID"
# sql_table_id = "YOUR_SQL_TABLE_ID"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    cloud_sql_source=discoveryengine.CloudSqlSource(
        project_id=sql_project_id,
        instance_id=sql_instance_id,
        database_id=sql_database_id,
        table_id=sql_table_id,
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importa da Spanner

Nota: l'importazione dei dati da Spanner è in Anteprima pubblica.

Per importare i dati da Spanner, segui i passaggi riportati di seguito per creare un datastore e importare i dati utilizzando la console Google Cloud o l'API.

Configurare l'accesso a Spanner da un altro progetto

Se i dati di Spanner si trovano nello stesso progetto di Vertex AI Search, vai a Importare i dati da Spanner.

Per concedere a Vertex AI Search l'accesso ai dati Spanner in un progetto diverso, segui questi passaggi:

1. Sostituisci la seguente variabile PROJECT_NUMBER con il numero del progetto Vertex AI Search e poi copia i contenuti di questo blocco di codice. Questo è l'identificatore del tuo account di servizio Vertex AI Search:

   [e-mail]
   

2. Vai alla pagina IAM e amministrazione.

   IAM e amministrazione

3. Passa al tuo progetto Spanner nella pagina IAM e amministrazione e fai clic su Concedi l'accesso.

4. In Nuove entità, inserisci l'identificatore dell'account di servizio e seleziona una delle seguenti opzioni:

   • Se non utilizzerai il miglioramento dei dati durante l'importazione, seleziona il ruolo Cloud Spanner > Lettore database Cloud Spanner.
   • Se prevedi di utilizzare il miglioramento dei dati durante l'importazione, seleziona il ruolo Cloud Spanner > Amministratore database Cloud Spanner o un ruolo personalizzato con le autorizzazioni di Lettore database Cloud Spanner e spanner.databases.useDataBoost. Per informazioni su Data Boost, consulta la panoramica di Data Boost nella documentazione di Spanner.

5. Fai clic su Salva.

A questo punto, vai a Importare i dati da Spanner.

Importa dati da Spanner

Console

Per utilizzare la console per importare i dati da Spanner, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Cloud Spanner.

5. Specifica l'ID progetto, l'ID istanza, l'ID database e l'ID tabella dei dati che intendi importare.

6. Seleziona se attivare il potenziamento dei dati. Per informazioni su Data Boost, consulta la panoramica di Data Boost nella documentazione di Spanner.

7. Fai clic su Continua.

8. Scegli una regione per il tuo datastore.

9. Inserisci un nome per il tuo datastore.

10. Fai clic su Crea.

11. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del datastore per visualizzarne i dettagli nella pagina Dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Importazione completata, l'importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere diversi minuti o diverse ore.

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da Spanner:

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1alpha/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"],
     "contentConfig": "CONTENT_REQUIRED",
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Vertex AI Search.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo messaggio potrebbe essere visualizzato nella console Google Cloud.

2. Importa i dati da Spanner.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
     -d '{
       "cloudSpannerSource": {
         "projectId": "SPANNER_PROJECT_ID",
         "instanceId": "INSTANCE_ID",
         "databaseId": "DATABASE_ID",
         "tableId": "TABLE_ID",
         "enableDataBoost": "DATA_BOOST_BOOLEAN"
       },
       "reconciliationMode": "RECONCILIATION_MODE",
       "autoGenerateIds": "AUTO_GENERATE_IDS",
       "idField": "ID_FIELD",
     }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Vertex AI Search.
   • DATA_STORE_ID: l'ID del datastore.
   • SPANNER_PROJECT_ID: l'ID del tuo progetto Spanner.
   • INSTANCE_ID: l'ID dell'istanza Spanner.
   • DATABASE_ID: l'ID del tuo database Spanner.
   • TABLE_ID: l'ID della tabella Spanner.
   • DATA_BOOST_BOOLEAN: facoltativo. L'attivazione di Data Boost. Per informazioni su Data Boost, consulta la Panoramica di Data Boost nella documentazione di Spanner.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da Spanner al tuo datastore. Viene eseguita un'operazione upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo datastore e quelli che non sono in Spanner vengono rimossi dal tuo datastore. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.

   • AUTO_GENERATE_IDS: facoltativo. Specifica se generare automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati in base a un hash del payload. Tieni presente che gli ID documento generati potrebbero non rimanere coerenti in più importazioni. Se generi automaticamente gli ID in più importazioni, Google consiglia vivamente di impostare reconciliationMode su FULL per mantenere ID documento coerenti.

   • ID_FIELD: facoltativo. Specifica quali campi sono gli ID documento.

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# spanner_project_id = "YOUR_SPANNER_PROJECT_ID"
# spanner_instance_id = "YOUR_SPANNER_INSTANCE_ID"
# spanner_database_id = "YOUR_SPANNER_DATABASE_ID"
# spanner_table_id = "YOUR_SPANNER_TABLE_ID"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    spanner_source=discoveryengine.SpannerSource(
        project_id=spanner_project_id,
        instance_id=spanner_instance_id,
        database_id=spanner_database_id,
        table_id=spanner_table_id,
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importa da Firestore

Per importare i dati da Firestore, segui questi passaggi per creare un datastore e importare i dati utilizzando la console Google Cloud o l'API.

Se i tuoi dati Firestore si trovano nello stesso progetto di Vertex AI Search, vai a Importare i dati da Firestore.

Se i dati di Firestore si trovano in un progetto diverso da quello di Vertex AI Search, vai a Configurare l'accesso a Firestore.

Configurare l'accesso a Firestore da un altro progetto

Per concedere a Vertex AI Search l'accesso ai dati di Firestore che si trovano in un altro progetto:

1. Sostituisci la seguente variabile PROJECT_NUMBER con il numero del progetto Vertex AI Search e poi copia i contenuti di questo blocco di codice. Questo è l'identificatore del tuo account di servizio Vertex AI Search:

   [e-mail]
   

2. Vai alla pagina IAM e amministrazione.

   IAM e amministrazione

3. Passa al tuo progetto Firestore nella pagina IAM e amministrazione e fai clic su Concedi l'accesso.

4. In Nuove entità, inserisci l'identificatore dell'account di servizio dell'istanza e seleziona il ruolo Datastore > Amministratore di importazione ed esportazione di Cloud Datastore.

5. Fai clic su Salva.

6. Torna al progetto Vertex AI Search.

Poi vai a Importare i dati da Firestore.

Importa i dati da Firestore

Console

Per utilizzare la console per importare i dati da Firestore, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Vai alla pagina Datastore.

3. Fai clic su Nuovo datastore.

4. Nella pagina Origine, seleziona Firestore.

5. Specifica l'ID progetto, l'ID database e l'ID collezione dei dati che prevedi di importare.

6. Fai clic su Continua.

7. Scegli una regione per il tuo datastore.

8. Inserisci un nome per il tuo datastore.

9. Fai clic su Crea.

10. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del datastore per visualizzarne i dettagli nella pagina Dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Importazione completata, l'importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere diversi minuti o diverse ore.

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da Firestore:

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1alpha/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"],
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo messaggio potrebbe essere visualizzato nella console Google Cloud.

2. Importa i dati da Firestore.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
     -d '{
       "firestoreSource": {
         "projectId": "FIRESTORE_PROJECT_ID",
         "databaseId": "DATABASE_ID",
         "collectionId": "COLLECTION_ID",
       },
       "reconciliationMode": "RECONCILIATION_MODE",
       "autoGenerateIds": "AUTO_GENERATE_IDS",
       "idField": "ID_FIELD",
     }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Vertex AI Search.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • FIRESTORE_PROJECT_ID: l'ID del tuo progetto Firestore.
   • DATABASE_ID: l'ID del database Firestore.
   • COLLECTION_ID: l'ID della raccolta Firestore.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da Firestore al tuo datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo data store e quelli che non sono in Firestore vengono rimossi. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.
   • AUTO_GENERATE_IDS: facoltativo. Specifica se generare automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati in base a un hash del payload. Tieni presente che gli ID documento generati potrebbero non rimanere coerenti in più importazioni. Se generi automaticamente gli ID in più importazioni, Google consiglia vivamente di impostare reconciliationMode su FULL per mantenere ID documento coerenti.
   • ID_FIELD: facoltativo. Specifica quali campi sono gli ID documento.

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# firestore_project_id = "YOUR_FIRESTORE_PROJECT_ID"
# firestore_database_id = "YOUR_FIRESTORE_DATABASE_ID"
# firestore_collection_id = "YOUR_FIRESTORE_COLLECTION_ID"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    firestore_source=discoveryengine.FirestoreSource(
        project_id=firestore_project_id,
        database_id=firestore_database_id,
        collection_id=firestore_collection_id,
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importa da Bigtable

Nota: l'importazione dei dati da Bigtable è in Anteprima pubblica.

Per importare i dati da Bigtable, segui i passaggi riportati di seguito per creare un datastore e importare i dati utilizzando l'API.

Configurare l'accesso a Bigtable

Per concedere a Vertex AI Search l'accesso ai dati Bigtable in un progetto diverso:

1. Sostituisci la seguente variabile PROJECT_NUMBER con il numero del tuo progetto Vertex AI Search, quindi copia i contenuti di questo blocco di codice. Questo è l'identificatore del tuo account di servizio Vertex AI Search:

   [e-mail]`
   

2. Vai alla pagina IAM e amministrazione.

   IAM e amministrazione

3. Passa al tuo progetto Bigtable nella pagina IAM e amministrazione e fai clic su Concedi l'accesso.

4. In Nuove entità, inserisci l'identificatore dell'account di servizio dell'istanza e seleziona il ruolo Bigtable > Lettore Bigtable.

5. Fai clic su Salva.

6. Torna al progetto Vertex AI Search.

Poi vai a Importare i dati da Bigtable.

Importa dati da Bigtable

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da Bigtable:

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1alpha/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"],
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo messaggio potrebbe essere visualizzato nella console Google Cloud.

2. Importa i dati da Bigtable.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
     -d '{
       "bigtableSource ": {
         "projectId": "BIGTABLE_PROJECT_ID",
         "instanceId": "INSTANCE_ID",
         "tableId": "TABLE_ID",
         "bigtableOptions": {
           "keyFieldName": "KEY_FIELD_NAME",
           "families": {
             "key": "KEY",
             "value": {
               "fieldName": "FIELD_NAME",
               "encoding": "ENCODING",
               "type": "TYPE",
               "columns": [
                 {
                   "qualifier": "QUALIFIER",
                   "fieldName": "FIELD_NAME",
                   "encoding": "COLUMN_ENCODING",
                   "type": "COLUMN_VALUES_TYPE"
                 }
               ]
             }
            }
            ...
         }
       },
       "reconciliationMode": "RECONCILIATION_MODE",
       "autoGenerateIds": "AUTO_GENERATE_IDS",
       "idField": "ID_FIELD",
     }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Vertex AI Search.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • BIGTABLE_PROJECT_ID: l'ID del progetto Bigtable.
   • INSTANCE_ID: l'ID della tua istanza Bigtable.
   • TABLE_ID: l'ID della tabella Bigtable.
   • KEY_FIELD_NAME: facoltativo, ma consigliato. Il nome del campo da utilizzare per il valore della chiave di riga dopo l'importazione in Vertex AI Search.
   • KEY: obbligatorio. Un valore di stringa per la chiave della famiglia di colonne.
   • ENCODING: facoltativo. La modalità di codifica dei valori quando il tipo non è STRING.Questo valore può essere ignorato per una colonna specifica elencandola in columns e specificandone una codifica.
   • COLUMN_TYPE: facoltativo. Il tipo di valori di questa famiglia di colonne.
   • QUALIFIER: obbligatorio. Qualificatore della colonna.
   • FIELD_NAME: facoltativo, ma consigliato. Il nome del campo da utilizzare per questa colonna dopo l'importazione in Vertex AI Search.
   • COLUMN_ENCODING: facoltativo. La modalità di codifica dei valori per una colonna specifica quando il tipo non è STRING.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da Bigtable al tuo datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo datastore e quelli che non sono in Bigtable vengono rimossi. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.

   • AUTO_GENERATE_IDS: facoltativo. Specifica se generare automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati in base a un hash del payload. Tieni presente che gli ID documento generati potrebbero non rimanere coerenti in più importazioni. Se generi automaticamente gli ID in più importazioni, Google consiglia vivamente di impostare reconciliationMode su FULL per mantenere ID documento coerenti.

     Specifica autoGenerateIds solo quando bigquerySource.dataSchema è impostato su custom. In caso contrario, viene restituito un errore INVALID_ARGUMENT. Se non specifichi autoGenerateIds o lo imposti su false, devi specificare idField. In caso contrario, l'importazione dei documenti non andrà a buon fine.

   • ID_FIELD: facoltativo. Specifica quali campi sono gli ID documento.

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# bigtable_project_id = "YOUR_BIGTABLE_PROJECT_ID"
# bigtable_instance_id = "YOUR_BIGTABLE_INSTANCE_ID"
# bigtable_table_id = "YOUR_BIGTABLE_TABLE_ID"

#  For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

bigtable_options = discoveryengine.BigtableOptions(
    families={
        "family_name_1": discoveryengine.BigtableOptions.BigtableColumnFamily(
            type_=discoveryengine.BigtableOptions.Type.STRING,
            encoding=discoveryengine.BigtableOptions.Encoding.TEXT,
            columns=[
                discoveryengine.BigtableOptions.BigtableColumn(
                    qualifier="qualifier_1".encode("utf-8"),
                    field_name="field_name_1",
                ),
            ],
        ),
        "family_name_2": discoveryengine.BigtableOptions.BigtableColumnFamily(
            type_=discoveryengine.BigtableOptions.Type.INTEGER,
            encoding=discoveryengine.BigtableOptions.Encoding.BINARY,
        ),
    }
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    bigtable_source=discoveryengine.BigtableSource(
        project_id=bigtable_project_id,
        instance_id=bigtable_instance_id,
        table_id=bigtable_table_id,
        bigtable_options=bigtable_options,
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Importazione da AlloyDB per PostgreSQL

Nota: l'importazione dei dati da AlloyDB per PostgreSQL è in anteprima pubblica.

Per importare i dati da AlloyDB per PostgreSQL, segui questi passaggi per creare un datastore e importare i dati utilizzando la console Google Cloud o l'API.

Se i dati di AlloyDB per PostgreSQL si trovano nello stesso progetto del progetto Vertex AI Search, vai a Importare i dati da AlloyDB per PostgreSQL.

Se i dati di AlloyDB per PostgreSQL si trovano in un progetto diverso da quello di Vertex AI Search, vai a Configurare l'accesso ad AlloyDB per PostgreSQL.

Configurare l'accesso ad AlloyDB per PostgreSQL da un altro progetto

Per concedere a Vertex AI Search l'accesso ai dati di AlloyDB per PostgreSQL che si trovano in un progetto diverso, segui questi passaggi:

1. Sostituisci la seguente variabile PROJECT_NUMBER con il numero del progetto Vertex AI Search e poi copia i contenuti di questo blocco di codice. Questo è l'identificatore del tuo account di servizio Vertex AI Search:

   [e-mail]
   

2. Passa al progetto Google Cloud in cui si trovano i dati di AlloyDB per PostgreSQL.

3. Vai alla pagina IAM.

   IAM

4. Fai clic su Concedi l'accesso.

5. In Nuove entità, inserisci l'identificatore dell'account di servizio Vertex AI Search e seleziona il ruolo Cloud AlloyDB > Amministratore Cloud AlloyDB.

6. Fai clic su Salva.

7. Torna al progetto Vertex AI Search.

A questo punto, vai a Importare i dati da AlloyDB per PostgreSQL.

Importa i dati da AlloyDB per PostgreSQL

Console

Per utilizzare la console per importare i dati da AlloyDB per PostgreSQL, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Agent Builder.

   Agent Builder

2. Nel menu di navigazione, fai clic su Datastore.

3. Fai clic su Crea datastore.

4. Nella pagina Origine, seleziona AlloyDB.

5. Specifica l'ID progetto, l'ID posizione, l'ID cluster, l'ID database e l'ID tabella dei dati che intendi importare.

6. Fai clic su Continua.

7. Scegli una regione per il tuo datastore.

8. Inserisci un nome per il tuo datastore.

9. Fai clic su Crea.

10. Per controllare lo stato dell'importazione, vai alla pagina Datastore e fai clic sul nome del datastore per visualizzarne i dettagli nella pagina Dati. Quando la colonna dello stato nella scheda Attività passa da In corso a Importazione completata, l'importazione è completata.

    A seconda delle dimensioni dei dati, l'importazione può richiedere diversi minuti o diverse ore.

REST

Per utilizzare la riga di comando per creare un datastore e importare i dati da AlloyDB per PostgreSQL:

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1beta/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"],
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo messaggio potrebbe essere visualizzato nella console Google Cloud.

2. Importa i dati da AlloyDB per PostgreSQL.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents:import" \
     -d '{
       "alloydbSource": {
         "projectId": "ALLOYDB_PROJECT_ID",
         "locationId": "LOCATION_ID",
         "clusterId": "CLUSTER_ID",
         "databaseId": "DATABASE_ID",
         "tableId": "TABLE_ID",
       },
       "reconciliationMode": "RECONCILIATION_MODE",
       "autoGenerateIds": "AUTO_GENERATE_IDS",
       "idField": "ID_FIELD",
     }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Vertex AI Search.
   • DATA_STORE_ID: l'ID del datastore. L'ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • ALLOYDB_PROJECT_ID: l'ID del progetto AlloyDB per PostgreSQL.
   • LOCATION_ID: l'ID della tua località AlloyDB per PostgreSQL.
   • CLUSTER_ID: l'ID del tuo cluster AlloyDB per PostgreSQL.
   • DATABASE_ID: l'ID del database AlloyDB per PostgreSQL.
   • TABLE_ID: l'ID della tabella AlloyDB per PostgreSQL.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. La specifica di INCREMENTAL provoca un aggiornamento incrementale dei dati da AlloyDB per PostgreSQL al tuo datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce quelli esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene eseguita una rebase completa dei documenti nel tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti al tuo data store e quelli che non sono presenti in AlloyDB per PostgreSQL vengono rimossi dal tuo datastore. La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.
   • AUTO_GENERATE_IDS: facoltativo. Specifica se generare automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati in base a un hash del payload. Tieni presente che gli ID documento generati potrebbero non rimanere coerenti in più importazioni. Se generi automaticamente gli ID in più importazioni, Google consiglia vivamente di impostare reconciliationMode su FULL per mantenere ID documento coerenti.
   • ID_FIELD: facoltativo. Specifica quali campi sono gli ID documento.

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python Vertex AI Agent Builder.

Per autenticarti in Vertex AI Agent Builder, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Crea un datastore

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"


def create_data_store_sample(
    project_id: str,
    location: str,
    data_store_id: str,
) -> str:
    #  For more information, refer to:
    # https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
    client_options = (
        ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
        if location != "global"
        else None
    )

    # Create a client
    client = discoveryengine.DataStoreServiceClient(client_options=client_options)

    # The full resource name of the collection
    # e.g. projects/{project}/locations/{location}/collections/default_collection
    parent = client.collection_path(
        project=project_id,
        location=location,
        collection="default_collection",
    )

    data_store = discoveryengine.DataStore(
        display_name="My Data Store",
        # Options: GENERIC, MEDIA, HEALTHCARE_FHIR
        industry_vertical=discoveryengine.IndustryVertical.GENERIC,
        # Options: SOLUTION_TYPE_RECOMMENDATION, SOLUTION_TYPE_SEARCH, SOLUTION_TYPE_CHAT, SOLUTION_TYPE_GENERATIVE_CHAT
        solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
        # TODO(developer): Update content_config based on data store type.
        # Options: NO_CONTENT, CONTENT_REQUIRED, PUBLIC_WEBSITE
        content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
    )

    request = discoveryengine.CreateDataStoreRequest(
        parent=parent,
        data_store_id=data_store_id,
        data_store=data_store,
        # Optional: For Advanced Site Search Only
        # create_advanced_site_search=True,
    )

    # Make the request
    operation = client.create_data_store(request=request)

    print(f"Waiting for operation to complete: {operation.operation.name}")
    response = operation.result()

    # After the operation is complete,
    # get information from operation metadata
    metadata = discoveryengine.CreateDataStoreMetadata(operation.metadata)

    # Handle the response
    print(response)
    print(metadata)

    return operation.operation.name

Importa documenti

from google.api_core.client_options import ClientOptions
from google.cloud import discoveryengine_v1 as discoveryengine

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_LOCATION" # Values: "global"
# data_store_id = "YOUR_DATA_STORE_ID"
# alloy_db_project_id = "YOUR_ALLOY_DB_PROJECT_ID"
# alloy_db_location_id = "YOUR_ALLOY_DB_LOCATION_ID"
# alloy_db_cluster_id = "YOUR_ALLOY_DB_CLUSTER_ID"
# alloy_db_database_id = "YOUR_ALLOY_DB_DATABASE_ID"
# alloy_db_table_id = "YOUR_ALLOY_DB_TABLE_ID"

# For more information, refer to:
# https://cloud.google.com/generative-ai-app-builder/docs/locations#specify_a_multi-region_for_your_data_store
client_options = (
    ClientOptions(api_endpoint=f"{location}-discoveryengine.googleapis.com")
    if location != "global"
    else None
)

# Create a client
client = discoveryengine.DocumentServiceClient(client_options=client_options)

# The full resource name of the search engine branch.
# e.g. projects/{project}/locations/{location}/dataStores/{data_store_id}/branches/{branch}
parent = client.branch_path(
    project=project_id,
    location=location,
    data_store=data_store_id,
    branch="default_branch",
)

request = discoveryengine.ImportDocumentsRequest(
    parent=parent,
    alloy_db_source=discoveryengine.AlloyDbSource(
        project_id=alloy_db_project_id,
        location_id=alloy_db_location_id,
        cluster_id=alloy_db_cluster_id,
        database_id=alloy_db_database_id,
        table_id=alloy_db_table_id,
    ),
    # Options: `FULL`, `INCREMENTAL`
    reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)

# Make the request
operation = client.import_documents(request=request)

print(f"Waiting for operation to complete: {operation.operation.name}")
response = operation.result()

# After the operation is complete,
# get information from operation metadata
metadata = discoveryengine.ImportDocumentsMetadata(operation.metadata)

# Handle the response
print(response)
print(metadata)

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Carica dati JSON strutturati con l'API

Per caricare direttamente un documento o un oggetto JSON utilizzando l'API, segui questi passaggi.

Prima di importare i dati, preparali per l'importazione.

REST

Per utilizzare la riga di comando per creare un datastore e importare dati JSON strutturati, segui questi passaggi.

Nota: se vuoi specificare uno schema anziché lasciare che sia Vertex AI a rilevarlo automaticamente, segui i passaggi descritti in Fornire lo schema come oggetto JSON e poi inizia la procedura descritta di seguito dal passaggio 2.

1. Crea un datastore.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -H "X-Goog-User-Project: PROJECT_ID" \
   "https://discoveryengine.googleapis.com/v1alpha/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores?dataStoreId=DATA_STORE_ID" \
   -d '{
     "displayName": "DATA_STORE_DISPLAY_NAME",
     "industryVertical": "GENERIC",
     "solutionTypes": ["SOLUTION_TYPE_SEARCH"]
   }'
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.
   • DATA_STORE_ID: l'ID del datastore di Vertex AI Search che vuoi creare. Questo ID può contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DATA_STORE_DISPLAY_NAME: il nome visualizzato del datastore di ricerca Vertex AI che vuoi creare.

2. Importa i dati strutturati.

   Esistono diversi approcci che puoi utilizzare per caricare i dati, tra cui:

   • Carica un documento JSON.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1beta/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents?documentId=DOCUMENT_ID" \
     -d '{
       "jsonData": "JSON_DOCUMENT_STRING"
     }'
     

     Sostituisci quanto segue:

     • DOCUMENT_ID: un ID univoco per il documento. Questo ID può avere una lunghezza massima di 63 caratteri e contenere solo lettere minuscole, cifre, trattini bassi e trattini.

     • JSON_DOCUMENT_STRING: il documento JSON come singola stringa. Deve essere conforme allo schema JSON fornito nel passaggio precedente, ad esempio:

       { \"title\": \"test title\", \"categories\": [\"cat_1\", \"cat_2\"], \"uri\": \"test uri\"}
       

   • Carica un oggetto JSON.

     curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1beta/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents?documentId=DOCUMENT_ID" \
     -d '{
       "structData": JSON_DOCUMENT_OBJECT
     }'
     

     Sostituisci JSON_DOCUMENT_OBJECT con il documento JSON come oggetto JSON. Deve essere conforme allo schema JSON fornito nel passaggio precedente, ad esempio:

     ```json
     {
       "title": "test title",
       "categories": [
         "cat_1",
         "cat_2"
       ],
       "uri": "test uri"
     }
     ```
     

   • Aggiorna con un documento JSON.

     curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1beta/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents/DOCUMENT_ID" \
     -d '{
       "jsonData": "JSON_DOCUMENT_STRING"
     }'
     

   • Aggiorna con un oggetto JSON.

     curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://discoveryengine.googleapis.com/v1beta/projects/PROJECT_ID/locations/global/collections/default_collection/dataStores/DATA_STORE_ID/branches/0/documents/DOCUMENT_ID" \
     -d '{
       "structData": JSON_DOCUMENT_OBJECT
     }'
     

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi descritti in Creare un'app di ricerca.

• Per visualizzare l'anteprima dell'aspetto dei risultati di ricerca dopo la configurazione dell'app e del datastore, consulta Generare risultati di ricerca.

Risolvere i problemi di importazione dati

Se hai problemi con l'importazione dati, consulta questi suggerimenti:

• Se utilizzi chiavi di crittografia gestite dal cliente e l'importazione dei dati non va a buon fine (con il messaggio di errore The caller does not have permission), assicurati che il ruolo IAM Autore crittografia/decrittografia CryptoKey (roles/cloudkms.cryptoKeyEncrypterDecrypter) sulla chiave sia stato concesso all'agente di servizio Cloud Storage. Per saperne di più, consulta Prima di iniziare in "Chiavi di crittografia gestite dal cliente".

• Se utilizzi l'indicizzazione avanzata del sito web e l'utilizzo dei documenti per l'datastore è molto inferiore alle aspettative, rivedi i pattern URL specificati per l'indicizzazione e assicurati che coprano le pagine che vuoi indicizzare ed espandili se necessario. Ad esempio, se hai utilizzato *.en.example.com/*, potresti dover aggiungere *.example.com/* ai siti che vuoi indicizzare.

Creare un datastore utilizzando Terraform

Puoi utilizzare Terraform per creare un datastore vuoto. Dopo aver creato il datastore vuoto, puoi importare i dati utilizzando i comandi della console o dell'API Google Cloud.

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Per creare un datastore vuoto utilizzando Terraform, consulta google_discovery_engine_data_store.