Crea un datastore di ricerca

Per creare un datastore e importare i dati per la ricerca, vai alla sezione relativa al che intendi utilizzare:

• Creare un datastore utilizzando i contenuti del sito web
• Importa da BigQuery
• Importa da Cloud Storage
• Sincronizzare da Google Drive
• Importa da Cloud SQL
• Importazione da Spanner (anteprima pubblica)
• Importa da Firestore
• Importa da Bigtable (anteprima pubblica)
• Importazione da AlloyDB per PostgreSQL (anteprima pubblica)
• Caricare dati JSON strutturati con l'API
• Creare un data store utilizzando Terraform

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

Creare un datastore utilizzando i contenuti del sito web

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

Per utilizzare un data store del sito web dopo averlo creato, devi collegarlo a un'app in cui sono attive le funzionalità Enterprise. Puoi attivare Enterprise Edition per un'app quando lo 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 del sito 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 dei siti web offre funzionalità aggiuntive, come la ricerca riassunti, ricerche con follow-up e 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 da includere nel 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 la sezione Dati del sito web.

8. Fai clic su Continua.

9. Seleziona una località per il 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 datastore visualizza i tuoi datastore nella pagina Datastore.

12. Per visualizzare le informazioni sul 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 per verificare i domini nel datastore.
    • Se riscontri un calo della quota (il numero di pagine dei siti web che specificato supera il "Numero di documenti per progetto" quota per il tuo progetto), un ulteriore avviso che richiede l'upgrade della quota.

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

14. Per eseguire l'upgrade della quota:

    1. Fai clic su Esegui l'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 la quota da aumentare è Numero di documenti in Discovery Engine API.
    3. Dopo aver inviato la richiesta di un limite di quota superiore, torna alla Agent Builder e fai clic su Data Stores 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 di 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 pagina web l'indicizzazione nella sezione "Quote e limiti" .

Python

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

Per eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per maggiori 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 datastore dalle tabelle BigQuery in due modi:

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

• 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 BigQuery nei datastore di Vertex AI Search.

Importazione una tantum	Importazione periodica
In disponibilità generale (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 manualmente.
Vertex AI Search crea un singolo data store da una tabella in BigQuery.	Vertex AI Search crea un connettore di dati per un set di dati BigQuery e un data store (chiamato data store di 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 data store 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 data store delle entità possono provenire solo da una tabella BigQuery.
Il controllo dell'accesso all'origine dati è supportato.	Il 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 data store 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à.
conforme 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 data store e importare i dati utilizzando la console Google Cloud o l'API.

Prima di importare i dati, controlla Prepara i dati per l'importazione.

Console

Per utilizzare la console Google Cloud per importare i dati da BigQuery, 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 BigQuery.

5. Seleziona il tipo di dati che vuoi importare.

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 ulteriori informazioni, consulta Informazioni su rilevamento automatico e modifica.

   3. Fai clic su Continua.

10. Scegli una regione per il datastore.

11. Inserisci un nome per il 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 lettere, numeri, trattini bassi e trattini.
   • DATA_STORE_DISPLAY_NAME: il nome visualizzato di Vertex AI Cerca nel datastore che vuoi creare.

   (Facoltativo) Se carichi dati non strutturati e vuoi configurare il documento per l'analisi o per attivare il chunking dei documenti per RAG, specifica documentProcessingConfig e includerlo nella richiesta di creazione del datastore. La configurazione di un Il parser OCR per i PDF è consigliato se stai importando 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 a questo schema.

   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 spazio dati di Vertex AI Search.
   • DATASET_ID: l'ID dell'elemento BigQuery del set di dati.
   • 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 "Visualizzatore dati BigQuery" l'autorizzazione per 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 che utilizzi deve essere conforme allo standard BigQuery schema fornito Prepara i dati per l'importazione. Puoi definire tu stesso l'ID di ogni documento, durante il wrapping di 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 data store. 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, mentre quelli non presenti in BigQuery vengono rimossi. La La modalità FULL è utile se vuoi eliminare automaticamente i documenti che non ti servono più.

   • AUTO_GENERATE_IDS: facoltativo. Specifica se generano automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati sulla base di 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 su tipo di stringa, deve essere compreso tra 1 e 63 caratteri e deve essere conforme in RFC-1034. In caso contrario, l'importazione dei documenti non andrà a buon fine.

C#

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

Per eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 API Go di Vertex AI Agent Builder documentazione di riferimento.

Per autenticarti in Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 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 funzione, l'utente può trattare i dati personali come descritto in Addendum per il trattamento dei dati Cloud, soggetti alle limitazioni e agli obblighi applicabili previsti dal Contratto (così come definiti 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 associa un set di dati BigQuery con dati di Vertex AI Search e come specificare una tabella sul set di dati per ciascun datastore per creare. I datastore che sono figli dei connettori dati vengono chiamati entity e nei datastore.

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

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 che vuoi importare.

6. Fai clic su Periodico.

7. Seleziona Frequenza di sincronizzazione, la frequenza con cui vuoi che Connettore Vertex AI Search per la sincronizzazione con BigQuery del set di dati. Puoi modificare la frequenza in un secondo momento.

8. Nel campo Percorso set di dati BigQuery, fai clic su Sfoglia e seleziona il set di dati. che contiene le tabelle che hai preparato per 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 contenga i dati da utilizzare per il datastore.

   Nota: assicurati che i dati nelle tabelle corrispondano al tipo di dati selezionato nel passaggio 5.
   In caso di mancata corrispondenza, non verrai a conoscenza fino a quando 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 stringhe.

10. Se nel set di dati sono presenti altre tabelle che vuoi utilizzare datastore, 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.

    A questo punto hai creato un connettore dati che sincronizzerà periodicamente i dati con il set di dati BigQuery. Hai creato una o più entità e nei datastore. 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 La scheda Attività passa da In corso a Riuscito, la prima Importazione completata.

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

Dopo aver configurato l'origine dati e importato i dati la prima volta, il datastore sincronizza i dati da tale sorgente con la frequenza selezionata durante la configurazione. Circa un'ora dopo la creazione del connettore dati, avviene la prima sincronizzazione. 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 che l'app e il datastore sono per l'impostazione, consulta Visualizza i 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 data store. I dati nel datastore non cambiano a meno che tu aggiornare i dati manualmente.

• Importazione periodica: importi i dati da una cartella Cloud Storage oppure e imposti una frequenza di sincronizzazione che determina la frequenza con cui i dati il datastore viene aggiornato con i dati più recenti in ogni località.

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
In disponibilità generale (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 data store da una cartella o un file in Cloud Storage.	Vertex AI Search crea un connettore dati e vi associa un datastore (denominato datastore entity) per al file o alla cartella specificati. Ogni connettore di dati Cloud Storage può avere un singolo archivio dati delle entità.
I dati di più file, cartelle e bucket possono essere combinati in un unico un datastore importando prima i dati da una posizione di Cloud Storage quindi più dati da un'altra posizione.	Poiché l'importazione manuale dei dati non è supportata, i dati in un insieme di dati di entità possono provenire 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.	Il 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 data store 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à.
CMEK-compliant.	Non conforme a CMEK.

Importa una volta da Cloud Storage

Per importare 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 dati non è ricorsiva. Vale a dire, se sono presenti cartelle all'interno bucket o cartella specificati, 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 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 sede 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 datastore.

11. Inserisci un nome per il datastore.

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

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

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

13. Fai clic su Crea.

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

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

Nota: se importi dati strutturati e vuoi specificare uno schema, per consentire a Vertex AI di rilevare automaticamente lo schema, segui i passaggi in Fornisci il tuo schema come oggetto JSON e poi inizia la procedura seguente 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 lettere, numeri, trattini bassi e trattini.
   • DATA_STORE_DISPLAY_NAME: il nome visualizzato di Vertex AI Cerca nel datastore che vuoi creare.

   (Facoltativo) Per configurare l'analisi dei documenti o attivare il documento per RAG, specifica documentProcessingConfig e includerlo nella richiesta di creazione del datastore. La configurazione di un Il parser OCR per i PDF è consigliato se stai importando PDF scansionati. Per come per configurare le opzioni di analisi o chunking, consulta Analisi e chunking documenti.

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 spazio dati 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, un esempio di pattern del file di input è gs://<your-gcs-bucket>/directory/object.jsone un esempio di corrispondenza del pattern a uno o più file è gs://<your-gcs-bucket>/directory/*.json.

     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 assegnare all'account di servizio service-<project number>@gcp-sa-discoveryengine.iam.gserviceaccount.com le autorizzazioni "Visualizzatore oggetti Storage" per il bucket Cloud Storage. Per Ad esempio, se importi un bucket Cloud Storage progetto di origine "123" al progetto di destinazione "456", [e-mail] autorizzazioni per il bucket Cloud Storage nel progetto "123".

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

     • document: carica dati non strutturati con metadati per documenti non strutturati. Ogni riga del file deve seguire uno dei seguenti formati. Puoi definire l'ID di ciascun 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 JSON per i documenti strutturati. I dati vengono sono organizzate in base a uno schema. Puoi specificare lo schema. altrimenti viene rilevata 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 di il file CSV utilizzando il campo inputUris.

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

   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. Specifica INCREMENTAL causa un aggiornamento incrementale dei dati da Cloud Storage un datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti e sostituisce i documenti esistenti con quelli aggiornati 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 data store 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 generano automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati sulla base di un hash del payload. Tieni presente che ha generato gli ID documento potrebbero non rimanere coerenti in più importazioni. Se gli ID vengono generati automaticamente in più importazioni, Google ha consiglia di impostare reconciliationMode su FULL per mantenere gli ID dei documenti 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 non 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". che identifica tutti i pod Campi JSON con il nome "my_id" 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 di stringa, deve avere una lunghezza compresa 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 di stringa, deve essere compreso tra 1 e 63 caratteri e deve essere conforme in RFC-1034. In caso contrario, l'importazione dei documenti non andrà a buon fine.

C#

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

Per eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 API Go di Vertex AI Agent Builder documentazione di riferimento.

Per autenticarti in Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per maggiori 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 API Java di Vertex AI Agent Builder documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per maggiori 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, vedi Configura 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 eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 API Ruby di Vertex AI Agent Builder documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 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 funzione, l'utente può trattare i dati personali come descritto in Addendum per il trattamento dei dati Cloud, soggetti alle limitazioni e agli obblighi applicabili previsti dal Contratto (così come definiti 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 associa una località di Cloud Storage con dati di Vertex AI Search e come specificare una cartella o un file in quella posizione per i dati che vuoi creare. I datastore figli dei connettori dati sono chiamati datastore di entità.

I dati vengono sincronizzati periodicamente con il data store 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 vuoi importare.

6. Fai clic su Periodico.

7. Seleziona la frequenza della 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 di cui disponi. preparati per l'importazione, quindi 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, consulta Analisi documenti. Per informazioni sul frazionamento, consulta Eseguire il frazionamento dei documenti per RAG.

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

    Per selezionare un parser, espandi Opzioni di elaborazione documenti e specifica il le opzioni di parser che desideri 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'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 la prima volta, i dati vengono sincronizzati da tale sorgente con la frequenza selezionata durante la configurazione. Circa un'ora dopo la creazione del connettore dati, avviene la prima sincronizzazione. La sincronizzazione successiva avviene quindi circa 24 ore, 72 ore, o 120 ore dopo.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi Crea 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 da Google Drive

Nota: la sincronizzazione da Google Drive è disponibile solo per le app di ricerca generiche. Le app di chat, suggerimenti e agente non possono utilizzare origini dati di terze parti.

Per sincronizzare i dati da Google Drive, attieniti alla procedura seguente per creare: un datastore e importare i dati utilizzando la console Google Cloud.

I dati di Google Drive vengono sincronizzati continuamente con Vertex AI Search dopo crei il tuo datastore.

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 collegarti a Google Drive.

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

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

6. Inserisci un nome per il 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 un datastore per la ricerca.

Passaggi successivi

• Per collegare il datastore a un'app, crea un'app e seleziona il datastore seguendo i passaggi Crea 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 Accesso a Cloud SQL, creazione di un datastore e importazione dei dati.

Configura l'accesso gestione temporanea ai bucket per le istanze Cloud SQL

Durante l'importazione dei dati da Cloud SQL, i dati vengono prima impostati in una nel 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 prevedi di 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 sezione IAM e Console di amministrazione.

   IAM e Amministratore

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 la tua del progetto Vertex AI Search, quindi copia i contenuti di blocco di codice. Questo è il tuo account di servizio Vertex AI Search identificatore:

   [e-mail]`
   

2. Vai alla pagina IAM e amministrazione.

   IAM e amministrazione

3. Passa al tuo progetto Cloud SQL nella piattaforma IAM e Pagina Amministrazione e fai clic su Concedi l'accesso.

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

5. Fai clic su Salva.

Poi, vai a Importare i dati da Cloud SQL.

Importare dati da Cloud SQL

Console

Per utilizzare la console per importare i dati da Cloud SQL, segui questi passaggi: 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 prevedi di 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. Scegli 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 datastore.

10. Inserisci un nome per il 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

Utilizzare la riga di comando per creare un datastore e importare i dati da Cloud SQL, segui questi passaggi:

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ò Deve contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo potrebbe verranno visualizzate 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ò Deve 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 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 data store. 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 generato un rebase completo dei documenti nei tuoi dati . 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. La modalità FULL è utile se vuoi elimineranno 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, vedi Configura 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 dati da Spanner, segui questi passaggi per creare un datastore e importare i dati utilizzando la console Google Cloud o l'API.

Configura l'accesso a Spanner da un progetto diverso

Se i dati Spanner si trovano nello stesso progetto di Vertex AI Search, passa a Importa 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 la tua di Vertex AI Search, quindi copia il contenuto di questo di blocco di codice. Questo è il tuo account di servizio Vertex AI Search identificatore:

   [e-mail]
   

2. Vai alla sezione IAM e Console di amministrazione.

   IAM e Amministratore

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 per l'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 Data Boost durante l'importazione, seleziona 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.

Poi, 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 prevedi di importare.

6. Scegli se attivare o meno Data Boost. Per informazioni su Data Boost, vedi Panoramica di Data Boost nella documentazione di Spanner.

7. Fai clic su Continua.

8. Scegli una regione per il datastore.

9. Inserisci un nome per il 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 data store e importare i dati da Spanner:

1. Creare 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 della tua 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 Data Boost panoramica nel 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. Questa operazione esegue l'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, mentre quelli che non sono in Spanner 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 gli ID vengono generati automaticamente in più importazioni, Google ha consiglia di impostare reconciliationMode su FULL per mantenere gli ID dei documenti coerenti.

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

Python

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

Per autenticarti in Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 Crea 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 Importa dati da Firestore.

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

Configura 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 è il tuo account di servizio Vertex AI Search identificatore:

   [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 tuo progetto Vertex AI Search.

Quindi, vai a Importare i dati da Firestore.

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

8. Inserisci un nome per il 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

Utilizzare la riga di comando per creare un datastore e importare i dati da Firestore, segui questi passaggi:

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ò Deve 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 di Firestore per configurare un database.
   • COLLECTION_ID: l'ID della raccolta Firestore.
   • RECONCILIATION_MODE: facoltativo. I valori sono FULL e INCREMENTAL. Il valore predefinito è INCREMENTAL. Specifica INCREMENTAL provoca un aggiornamento incrementale dei dati da Firestore un datastore. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti sostituisce i documenti esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene generato un rebase completo dei documenti nei tuoi dati . In altre parole, i documenti nuovi e aggiornati vengono aggiunti ai tuoi dati , mentre i documenti non in Firestore vengono rimossi dal tuo datastore. La modalità FULL è utile se vuoi elimineranno automaticamente i documenti che non ti servono più.
   • AUTO_GENERATE_IDS: facoltativo. Specifica se generano automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati sulla base di un hash del payload. Tieni presente che ha generato gli ID documento potrebbero non rimanere coerenti in più importazioni. Se gli ID vengono generati automaticamente in più importazioni, Google ha consiglia di impostare reconciliationMode su FULL per mantenere gli ID dei documenti coerenti.
   • ID_FIELD: facoltativo. Specifica quali campi sono ID documento.

Python

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

Per autenticarti in Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per maggiori 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 che l'app e il datastore sono per l'impostazione, consulta Visualizza i risultati di ricerca.

Importa da Bigtable

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

Per importare dati da Bigtable, segui questi passaggi 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 di un altro progetto, segui questi passaggi:

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 sezione IAM e Console di amministrazione.

   IAM e amministrazione

3. Passa al tuo progetto Bigtable nella piattaforma IAM e Pagina Amministrazione e fai clic su Concedi l'accesso.

4. In Nuove entità, inserisci l'identificatore dell'account di servizio dell'istanza e seleziona 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

Utilizzare la riga di comando per creare un datastore e importare i dati da Bigtable, segui questi passaggi:

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ò Deve contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo potrebbe verranno visualizzate 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 del tuo Bigtable in esecuzione in un'istanza Compute Engine.
   • TABLE_ID: l'ID della tabella Bigtable.
   • KEY_FIELD_NAME: facoltativo ma consigliato. Il nome del campo da come valore chiave di riga dopo l'importazione in Vertex AI Search.
   • KEY: obbligatorio. Un valore di stringa per la chiave di famiglia di colonne.
   • ENCODING: facoltativo. La modalità di codifica dei valori quando il tipo non è STRING.Può essere sostituito per una colonna specifica elenca la colonna in columns e ne specifica una codifica.
   • COLUMN_TYPE: facoltativo. Il tipo di valori in questa colonna famiglia.
   • QUALIFIER: campo 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 quelli aggiornati lo stesso ID. Se specifichi FULL, viene generato un rebase completo dei documenti in del tuo datastore. In altre parole, i documenti nuovi e aggiornati vengono aggiunti del datastore e documenti non presenti in Bigtable vengono rimossi dal datastore. La modalità FULL è utile se: quando 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 non 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 ID documento.

Python

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

Per eseguire l'autenticazione su Vertex AI Agent Builder, configura le credenziali predefinite dell'applicazione. Per maggiori 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 Crea 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 AlloyDB per PostgreSQL

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

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

Configura l'accesso ad AlloyDB per PostgreSQL da un progetto diverso

Per concedere a Vertex AI Search l'accesso ai dati AlloyDB per PostgreSQL, di un altro progetto, 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'account di servizio Vertex AI Search identificatore e seleziona Cloud AlloyDB > Amministratore Cloud AlloyDB.

6. Fai clic su Salva.

7. Torna al tuo progetto Vertex AI Search.

Poi, vai a Importare 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 località, l'ID cluster, l'ID database e l'ID tabella dei dati che prevedi di importare.

6. Fai clic su Continua.

7. Scegli una regione per il datastore.

8. Inserisci un nome per il 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

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ò Deve contenere solo lettere minuscole, cifre, trattini bassi e trattini.
   • DISPLAY_NAME: il nome visualizzato del datastore. Questo potrebbe verranno visualizzate 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 di AlloyDB per PostgreSQL in ogni località.
   • CLUSTER_ID: l'ID del tuo cluster AlloyDB per PostgreSQL.
   • DATABASE_ID: l'ID di AlloyDB per PostgreSQL per configurare un database.
   • TABLE_ID: l'ID di AlloyDB per PostgreSQL tabella.
   • 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 data store. Viene eseguita un'operazione di upsert, che aggiunge nuovi documenti sostituisce i documenti esistenti con documenti aggiornati con lo stesso ID. Se specifichi FULL, viene generato un rebase completo dei documenti nei tuoi dati . 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 data store. La modalità FULL è utile se vuoi elimineranno automaticamente i documenti che non ti servono più.
   • AUTO_GENERATE_IDS: facoltativo. Specifica se generano automaticamente gli ID documento. Se impostato su true, gli ID documento vengono generati sulla base di un hash del payload. Tieni presente che ha generato gli ID documento potrebbero non rimanere coerenti in più importazioni. Se gli ID vengono generati automaticamente in più importazioni, Google ha consiglia di impostare reconciliationMode su FULL per mantenere gli ID dei documenti coerenti.
   • ID_FIELD: facoltativo. Specifica quali campi sono ID documento.

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, Prepara i dati per l'importazione.

REST

Per utilizzare la riga di comando per creare un data store 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. Creare 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 lettere, numeri, trattini bassi e trattini.
   • DATA_STORE_DISPLAY_NAME: il nome visualizzato di Vertex AI Cerca nel datastore 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. lettere, numeri, 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"
     }
     ```
     

   • Esegui l'aggiornamento 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"
     }'
     

   • Esegui l'aggiornamento 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 che l'app e il datastore sono per l'impostazione, consulta Visualizza i risultati di ricerca.

Risolvere i problemi di importazione dati

In caso di problemi con 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'armadietto dei dati è 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 usare Terraform per creare un datastore vuoto. Dopo aver creato il data store 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 data store vuoto utilizzando Terraform, consulta google_discovery_engine_data_store.