Creare un assistente Shopping intelligente con AlloyDB e Vertex AI Agent Builder - Parte 1

1. Panoramica

Nel panorama del retail odierno in rapida evoluzione, offrire un servizio clienti eccezionale e consentire esperienze di shopping personalizzate è fondamentale. Ti accompagneremo in un percorso tecnico attraverso la creazione di un'applicazione di chat basata sulla conoscenza progettata per rispondere alle domande dei clienti, guidare la scoperta dei prodotti e personalizzare i risultati di ricerca. Questa soluzione innovativa combina la potenza di AlloyDB per l'archiviazione dei dati, un motore di analisi interno per la comprensione contestuale, Gemini (Large Language Model) per la convalida della pertinenza e Agent Builder di Google per avviare rapidamente un assistente conversazionale intelligente.

La sfida: i clienti del settore retail moderno si aspettano risposte immediate e consigli sui prodotti in linea con le loro preferenze uniche. I metodi di ricerca tradizionali spesso non riescono a fornire questo livello di personalizzazione.

La soluzione: la nostra applicazione di chat basata sulla conoscenza affronta direttamente questa sfida. Sfrutta una knowledge base ricca derivata dai tuoi dati di vendita al dettaglio per comprendere l'intento dei clienti, rispondere in modo intelligente e fornire risultati estremamente pertinenti.

Cosa creerai

Nell'ambito di questo lab (parte 1), imparerai a:

1. Crea un'istanza AlloyDB e carica il set di dati sull'e-commerce
2. Abilita le estensioni pgvector e del modello di AI generativa in AlloyDB
3. Generare incorporamenti dalla descrizione del prodotto
4. Eseguire la ricerca della similarità del coseno in tempo reale per il testo di ricerca dell'utente
5. Esegui il deployment della soluzione in Cloud Run Functions serverless

La seconda parte del lab tratterà i passaggi di Agent Builder.

Requisiti

• Un browser, ad esempio Chrome o Firefox
• Un progetto Google Cloud con la fatturazione abilitata.

2. Architettura

Flusso di dati: vediamo più da vicino come si spostano i dati nel nostro sistema:

Importazione:

Il primo passaggio consiste nell'importare i dati Retail (inventario, descrizioni dei prodotti, interazioni con i clienti) in AlloyDB.

Motore di analisi:

Utilizzeremo AlloyDB come motore di analisi per eseguire le seguenti operazioni:

1. Estrazione del contesto: il motore analizza i dati archiviati in AlloyDB per comprendere le relazioni tra prodotti, categorie, comportamento dei clienti e così via, a seconda dei casi.
2. Creazione di incorporamenti: vengono generati incorporamenti (rappresentazioni matematiche del testo) sia per la query dell'utente sia per le informazioni archiviate in AlloyDB.
3. Ricerca vettoriale: il motore esegue una ricerca di similarità, confrontando l'embedding della query con gli embedding delle descrizioni dei prodotti, delle recensioni e di altri dati pertinenti. Vengono identificati i 25 "vicini più prossimi" più pertinenti.

Convalida di Gemini:

Queste potenziali risposte vengono inviate a Gemini per la valutazione. Gemini determina se sono davvero pertinenti e sicuri da condividere con l'utente.

Generazione di risposte:

Le risposte convalidate sono strutturate in un array JSON e l'intero motore è incluso in una funzione Cloud Run serverless richiamata da Agent Builder.

Interazione conversazionale:

Agent Builder presenta le risposte all'utente in un formato di linguaggio naturale, facilitando un dialogo continuo. Questa parte verrà trattata in un lab successivo.

3. Prima di iniziare

Crea un progetto

1. Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
2. Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto .
3. Utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione in Google Cloud precaricato con bq. Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud.

4. Una volta eseguita la connessione a Cloud Shell, verifica di essere già autenticato e che il progetto sia impostato sul tuo ID progetto utilizzando il seguente comando:

gcloud auth list

5. Esegui questo comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto.

gcloud config list project

6. Se il progetto non è impostato, utilizza il seguente comando per impostarlo:

gcloud config set project <YOUR_PROJECT_ID>

7. Abilita le API richieste.

gcloud services enable alloydb.googleapis.com \
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com

L'alternativa al comando gcloud è tramite la console, cercando ogni prodotto o utilizzando questo link.

Se manca un'API, puoi sempre abilitarla durante l'implementazione.

Consulta la documentazione per i comandi e l'utilizzo di gcloud.

4. Configurazione del database

In questo lab utilizzeremo AlloyDB come database per contenere i dati di vendita al dettaglio. Utilizza i cluster per contenere tutte le risorse, come database e log. Ogni cluster ha un'istanza primaria che fornisce un punto di accesso ai dati. Le tabelle conterranno i dati effettivi.

Creiamo un cluster, un'istanza e una tabella AlloyDB in cui verrà caricato il set di dati di e-commerce.

Crea un cluster e un'istanza

1. Vai alla pagina AlloyDB nella console Cloud. Un modo semplice per trovare la maggior parte delle pagine in Cloud Console è cercarle utilizzando la barra di ricerca della console.
2. Seleziona CREA CLUSTER da questa pagina:

3. Vedrai una schermata come quella riportata di seguito. Crea un cluster e un'istanza con i seguenti valori:

• cluster id: "shopping-cluster"
• password: "alloydb"
• Compatibile con PostgreSQL 15
• Regione: "us-central1"
• Networking: "default"

4. Quando selezioni la rete predefinita, viene visualizzata una schermata come quella riportata di seguito. Seleziona CONFIGURA CONNESSIONE.
   
5. Da qui, seleziona "Utilizza un intervallo IP allocato automaticamente" e fai clic su Continua. Dopo aver esaminato le informazioni, seleziona CREA CONNESSIONE.
6. Una volta configurata la rete, puoi continuare a creare il cluster. Fai clic su CREA CLUSTER per completare la configurazione del cluster come mostrato di seguito:

Assicurati di modificare l'ID istanza in "shopping-instance".

Tieni presente che la creazione del cluster richiederà circa 10 minuti. Una volta completata l'operazione, dovresti visualizzare una schermata simile a questa:

5. Importazione dati

Ora è il momento di aggiungere una tabella con i dati del negozio. Vai ad AlloyDB, seleziona il cluster principale e poi AlloyDB Studio:

Potrebbe essere necessario attendere il completamento della creazione dell'istanza. Una volta creato, accedi ad AlloyDB utilizzando le credenziali che hai creato durante la creazione del cluster. Utilizza i seguenti dati per l'autenticazione a PostgreSQL:

• Nome utente : "postgres"
• Database : "postgres"
• Password : "alloydb"

Una volta eseguita l'autenticazione in AlloyDB Studio, i comandi SQL vengono inseriti nell'editor. Puoi aggiungere più finestre dell'editor utilizzando il segno più a destra dell'ultima finestra.

Inserirai i comandi per AlloyDB nelle finestre dell'editor, utilizzando le opzioni Esegui, Formatta e Cancella in base alle esigenze.

Attivare le estensioni

Per creare questa app, utilizzeremo le estensioni pgvector e google_ml_integration. L'estensione pgvector consente di archiviare ed eseguire ricerche di vector embedding. L'estensione google_ml_integration fornisce funzioni che utilizzi per accedere agli endpoint di previsione Vertex AI per ottenere previsioni in SQL. Attiva queste estensioni eseguendo i seguenti DDL:

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

Se vuoi controllare le estensioni abilitate sul tuo database, esegui questo comando SQL:

select extname, extversion from pg_extension;

Creare una tabella

Crea una tabella utilizzando l'istruzione DDL riportata di seguito:

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

Se il comando precedente viene eseguito correttamente, dovresti essere in grado di visualizzare la tabella nel database. Di seguito è riportato uno screenshot di esempio:

Importa i dati

Per questo lab, abbiamo dati di test di circa 200 record in questo file SQL. Contiene id, category, sub_category, uri, image e content. Gli altri campi verranno compilati più tardi nel lab.

Copia le 20 righe/istruzioni di inserimento e incollale in una scheda dell'editor vuota, quindi seleziona ESEGUI.

Per visualizzare i contenuti della tabella, espandi la sezione Explorer finché non vedi la tabella denominata apparels. Seleziona il simbolo dei tre puntini (⋮) per visualizzare l'opzione per eseguire una query sulla tabella. Un'istruzione SELECT si aprirà in una nuova scheda dell'editor.

Concedi autorizzazione

Esegui l'istruzione riportata di seguito per concedere i diritti di esecuzione sulla funzione embedding all'utente postgres:

GRANT EXECUTE ON FUNCTION embedding TO postgres;

Concedi il ruolo Utente Vertex AI al service account AlloyDB

Vai al terminale Cloud Shell ed esegui questo comando:

PROJECT_ID=$(gcloud config get-value project)

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

6. Contesto

Torna alla pagina Istanza AlloyDB.

Per creare un incorporamento, abbiamo bisogno di un context, ovvero tutte le informazioni che vogliamo includere in un unico campo. A questo scopo, creeremo una descrizione del prodotto (che chiameremo pdt_desc). Nel nostro caso, utilizzeremo tutte le informazioni su ciascun prodotto, ma quando lo fai con i tuoi dati, sentiti libero di organizzarli nel modo che ritieni più significativo per la tua attività.

Esegui la seguente istruzione da AlloyDB Studio della tua istanza appena creata. In questo modo, il campo pdt_desc verrà aggiornato con i dati contestuali:

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

Questa istruzione DML crea un semplice riepilogo del contesto utilizzando le informazioni di tutti i campi disponibili nella tabella e altre dipendenze (se presenti nel tuo caso d'uso). Per un assortimento più preciso di informazioni e la creazione di un contesto, sentiti libero di manipolare i dati nel modo che ritieni più significativo per la tua attività.

7. Crea incorporamenti per il contesto

Per i computer è molto più facile elaborare i numeri che il testo. Un sistema di incorporamento converte il testo in una serie di numeri in virgola mobile che dovrebbero rappresentare il testo, indipendentemente dalla formulazione, dalla lingua utilizzata e così via.

Prendi in considerazione la descrizione di una località balneare. Potrebbe essere chiamato "sull'acqua", "fronte spiaggia", "a pochi passi dalla camera all'oceano", "sur la mer", "на берегу океана" e così via. Questi termini hanno un aspetto diverso, ma il loro significato semantico o, in termini di machine learning, i loro incorporamenti dovrebbero essere molto simili tra loro.

Ora che i dati e il contesto sono pronti, eseguiamo il codice SQL per aggiungere gli incorporamenti della descrizione del prodotto alla tabella nel campo embedding. Esistono diversi modelli di incorporamento che puoi utilizzare. Stiamo utilizzando text-embedding-004 da Vertex AI. Assicurati di utilizzare lo stesso modello di embedding per tutto il progetto.

Nota: se utilizzi un progetto Google Cloud esistente creato un po' di tempo fa, potresti dover continuare a utilizzare versioni precedenti del modello di incorporamento di testo, come textembedding-gecko.

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-004',
   pdt_desc)
WHERE
 TRUE;

Dai un'occhiata di nuovo alla tabella apparels per vedere alcuni incorporamenti. Assicurati di eseguire di nuovo l'istruzione SELECT per visualizzare le modifiche.

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 apparels;

Dovrebbe restituire il vettore di embedding, che ha l'aspetto di un array di numeri in virgola mobile, per il testo di esempio nella query, come mostrato di seguito:

Nota:i progetti Google Cloud appena creati nel Livello senza costi potrebbero riscontrare problemi di quota per quanto riguarda il numero di richieste di incorporamento consentite al secondo ai modelli di incorporamento. Ti suggeriamo di utilizzare una query di filtro per l'ID e poi di scegliere in modo selettivo 1-5 record e così via, durante la generazione dell'incorporamento.

8. Esegui la ricerca vettoriale

Ora che la tabella, i dati e gli embedding sono pronti, eseguiamo la ricerca vettoriale in tempo reale per il testo di ricerca dell'utente.

Supponiamo che l'utente chieda:

"Voglio top da donna, casual rosa solo in puro cotone."

Puoi trovare le corrispondenze eseguendo la query riportata di seguito:

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-004',
  'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
5;

Analizziamo questa query nel dettaglio:

In questa query,

1. Il testo di ricerca dell'utente è: "Voglio maglie da donna, rosa casual solo in puro cotone".
2. Lo stiamo convertendo in incorporamenti nel metodo embedding() utilizzando il modello: text-embedding-004. Questo passaggio dovrebbe sembrarti familiare dopo l'ultimo, in cui abbiamo applicato la funzione di incorporamento a tutti gli elementi della tabella.
3. "<=>" rappresenta l'utilizzo del metodo di distanza COSINE SIMILARITY. Puoi trovare tutte le misure di similarità disponibili nella documentazione di pgvector.
4. Stiamo convertendo il risultato del metodo di embedding in tipo vettoriale per renderlo compatibile con i vettori archiviati nel database.
5. LIMIT 5 indica che vogliamo estrarre i 5 vicini più prossimi per il testo di ricerca.

Il risultato è simile al seguente:

Come puoi notare nei risultati, le corrispondenze sono molto simili al testo di ricerca. Prova a cambiare il colore per vedere come cambiano i risultati.

Nota importante:

Supponiamo ora di voler aumentare il rendimento (tempo di query), l'efficienza e il richiamo di questo risultato della ricerca vettoriale utilizzando l'indice ScaNN. Leggi i passaggi descritti in questo blog per confrontare la differenza nel risultato con e senza l'indice. Per comodità, ecco i passaggi per la creazione dell'indice:

1. Poiché abbiamo già creato il cluster, l'istanza, il contesto e gli incorporamenti, dobbiamo solo installare l'estensione ScaNN utilizzando la seguente istruzione:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

2. A questo punto, creiamo l'indice (ScaNN):

CREATE INDEX apparel_index ON apparels

USING scann (embedding cosine)

WITH (num_leaves=54);

Nel DDL riportato sopra, apparel_index è il nome dell'indice

"apparels" è la mia tabella

"scann" è il metodo di indicizzazione

"embedding" è la colonna della tabella che voglio indicizzare

"cosine" è il metodo di distanza che voglio utilizzare con l'indice

"54" è il numero di partizioni da applicare a questo indice. Imposta un valore compreso tra 1 e 1048576. Per ulteriori informazioni su come decidere questo valore, vedi Ottimizzare un indice ScaNN.

Ho utilizzato la RADICE QUADRATA del numero di punti dati come consigliato nel repository ScaNN (durante il partizionamento, num_leaves deve essere approssimativamente la radice quadrata del numero di punti dati).

3. Controlla se l'indice è stato creato utilizzando la query:

SELECT * FROM pg_stat_ann_indexes;

4. Esegui Vector Search utilizzando la stessa query che abbiamo utilizzato senza l'indice:

select * from apparels

ORDER BY embedding <=> CAST(embedding('textembedding-gecko', 'white tops for girls without any print') as vector(768))

LIMIT 20

La query precedente è la stessa che abbiamo utilizzato nel lab al passaggio 8. Tuttavia, ora il campo è indicizzato.

5. Esegui il test con una semplice query di ricerca con e senza l'indice (eliminando l'indice):

white tops for girls without any print

Il testo di ricerca riportato sopra nella query Vector Search sui risultati dei dati degli incorporamenti INDEXED produce risultati di ricerca di qualità ed efficienza. L'efficienza è notevolmente migliorata (in termini di tempo di esecuzione: 10,37 ms senza ScaNN e 0,87 ms con ScaNN) con l'indice. Per saperne di più su questo argomento, consulta questo blog.

9. Convalida della corrispondenza con l'LLM

Prima di procedere e creare un servizio per restituire le corrispondenze migliori a un'applicazione, utilizziamo un modello di AI generativa per verificare se queste potenziali risposte sono davvero pertinenti e sicure da condividere con l'utente.

Assicurarsi che l'istanza sia configurata per Gemini

Innanzitutto, controlla se l'integrazione di Google ML è già attivata per il tuo cluster e la tua istanza. In AlloyDB Studio, esegui questo comando:

show google_ml_integration.enable_model_support;

Se il valore è visualizzato come "on", puoi saltare i due passaggi successivi e passare direttamente alla configurazione dell'integrazione di AlloyDB e del modello Vertex AI.

1. Vai all'istanza principale del cluster AlloyDB e fai clic su MODIFICA ISTANZA PRINCIPALE.

2. Vai alla sezione Flag nelle opzioni di configurazione avanzata. e assicurati che google_ml_integration.enable_model_support flag sia impostato su "on" come mostrato di seguito:

Se non è impostato su "on", impostalo su "on" e poi fai clic sul pulsante AGGIORNA ISTANZA. Questo passaggio richiederà alcuni minuti.

Integrazione di AlloyDB e Vertex AI Model

Ora puoi connetterti ad AlloyDB Studio ed eseguire la seguente istruzione DML per configurare l'accesso al modello Gemini da AlloyDB, utilizzando l'ID progetto dove indicato. Potresti ricevere un avviso di errore di sintassi prima di eseguire il comando, ma dovrebbe funzionare correttamente.

Per prima cosa, creiamo la connessione al modello Gemini 1.5 come mostrato di seguito. Ricorda di sostituire $PROJECT_ID nel comando seguente con il tuo ID progetto Google Cloud.

CALL
 google_ml.create_model( model_id => 'gemini-1.5',
   model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-1.5-pro:streamGenerateContent',
   model_provider => 'google',
   model_auth_type => 'alloydb_service_agent_iam');

Puoi controllare i modelli configurati per l'accesso tramite il seguente comando in AlloyDB Studio:

select model_id,model_type from google_ml.model_info_view;        

Infine, dobbiamo concedere l'autorizzazione agli utenti del database per eseguire la funzione ml_predict_row per eseguire le previsioni tramite i modelli Google Vertex AI. Esegui questo comando:

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

Nota: se utilizzi un progetto Google Cloud esistente e un cluster/un'istanza di AlloyDB esistente creati un po' di tempo fa, potresti dover eliminare i vecchi riferimenti al modello gemini-1.5 e crearli di nuovo con l'istruzione CALL riportata sopra ed eseguire di nuovo grant execute on function ml_predict_row nel caso in cui si verifichino problemi nelle prossime invocazioni di gemini-1.5.

Valutazione delle risposte

Anche se nella sezione successiva utilizzeremo una query di grandi dimensioni per assicurarci che le risposte siano ragionevoli, la query può essere difficile da comprendere. Ora esamineremo i vari elementi e vedremo come si combinano tra loro tra qualche minuto.

1. Innanzitutto invieremo una richiesta al database per ottenere le 5 corrispondenze più vicine a una query utente. Per semplificare, codificheremo la query in modo permanente, ma non preoccuparti, la interpoleremo nella query in un secondo momento. Stiamo includendo la descrizione del prodotto dalla tabella apparels e aggiungendo due nuovi campi: uno che combina la descrizione con l'indice e un altro con la richiesta originale. Tutto viene salvato in una tabella denominata xyz (solo un nome temporaneo).

CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-004',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

L'output di questa query sarà costituito dalle 5 righe più simili relative alla query degli utenti. La nuova tabella xyz conterrà 5 righe, ognuna delle quali avrà le seguenti colonne:

• literature
• content
• user_text

2. Per determinare la validità delle risposte, utilizzeremo una query complessa in cui spieghiamo come valutarle. Utilizza user_text e content nella tabella xyz come parte della query.

"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."

3. Utilizzando questa query, esamineremo quindi la "qualità" delle risposte nella tabella xyz.

CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;

4. predict_row restituisce il risultato in formato JSON. Il codice "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'"" viene utilizzato per estrarre il testo effettivo dal JSON. Per visualizzare il JSON effettivo restituito, puoi rimuovere questo codice.
5. Infine, per ottenere il campo LLM, devi estrarlo dalla tabella x:

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. Queste informazioni possono essere combinate in un'unica query successiva come segue.

Se hai eseguito le query precedenti per controllare i risultati intermedi, prima di eseguire questa query devi eliminare/rimuovere le tabelle xyz e x dal database AlloyDB.

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-004',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

Anche se può sembrare ancora scoraggiante, speriamo che ora tu possa capirci qualcosa in più. I risultati indicano se esiste una corrispondenza, la percentuale di corrispondenza e una spiegazione della classificazione.

Tieni presente che lo streaming è attivo per impostazione predefinita nel modello Gemini, quindi la risposta effettiva è distribuita su più righe:

10. Portare l'applicazione sul web

È tutto pronto per portare questa app sul web? Per rendere Knowledge Engine serverless con Cloud Run Functions, segui questi passaggi:

1. Vai a Cloud Run Functions nella console Google Cloud per CREARE una nuova funzione Cloud Run o utilizza il link: https://console.cloud.google.com/functions/add.
2. Seleziona "Cloud Run function" come ambiente. Fornisci il nome della funzione "retail-engine" e scegli la regione "us-central1". Imposta l'autenticazione su "Consenti chiamate non autenticate" e fai clic su AVANTI. Scegli Java 17 come runtime e Editor incorporato per il codice sorgente.
3. Per impostazione predefinita, l'entry point è impostato su "gcfv2.HelloHttpFunction". Sostituisci il codice segnaposto in HelloHttpFunction.java e pom.xml della funzione Cloud Run con il codice del file Java e dell'XML rispettivamente.
4. Ricorda di modificare il segnaposto $PROJECT_ID e le credenziali di connessione AlloyDB con i tuoi valori nel file Java. Le credenziali di AlloyDB sono quelle che abbiamo utilizzato all'inizio di questo codelab. Se hai utilizzato valori diversi, modificali nel file Java.
5. Fai clic su Esegui il deployment.

Una volta eseguito il deployment, per consentire alla funzione Cloud Functions di accedere all'istanza del database AlloyDB, creeremo il connettore VPC.

PASSAGGIO IMPORTANTE:

Una volta avviato il deployment, dovresti essere in grado di visualizzare le funzioni nella console Cloud Run Functions di Google. Cerca la funzione appena creata (retail-engine), fai clic su di essa, poi su MODIFICA e modifica quanto segue:

1. Vai a Impostazioni di runtime, build, connessioni e sicurezza
2. Aumenta il timeout a 180 secondi
3. Vai alla scheda CONNESSIONI:

4. Nelle impostazioni di Ingress, assicurati che sia selezionata l'opzione "Consenti tutto il traffico".
5. Nella sezione Impostazioni traffico in uscita, fai clic sul menu a discesa Rete, seleziona l'opzione "Aggiungi nuovo connettore VPC" e segui le istruzioni visualizzate nella finestra di dialogo visualizzata:

6. Fornisci un nome per il connettore VPC e assicurati che la regione sia la stessa dell'istanza. Lascia il valore Rete come predefinito e imposta Subnet come intervallo IP personalizzato con l'intervallo IP 10.8.0.0 o un valore simile disponibile.
7. Espandi MOSTRA IMPOSTAZIONI SCALATURA e assicurati che la configurazione sia impostata esattamente come segue:

8. Fai clic su CREA e il connettore dovrebbe essere ora elencato nelle impostazioni di uscita.
9. Seleziona il connettore appena creato.
10. Scegli di instradare tutto il traffico tramite questo connettore VPC.
11. Fai clic su AVANTI e poi su ESEGUI IL DEPLOYMENT.

11. testa l'applicazione

Una volta eseguito il deployment della funzione Cloud aggiornata, dovresti visualizzare l'endpoint nel seguente formato:

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/retail-engine

Puoi testarlo dal terminale Cloud Shell eseguendo il comando seguente:

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

In alternativa, puoi testare la funzione Cloud Run nel seguente modo:

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://us-central1-$PROJECT_ID.cloudfunctions.net/retail-engine \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

Il risultato:

È tutto. Eseguire la ricerca vettoriale di similarità utilizzando il modello di embedding sui dati AlloyDB è semplicissimo.

Creazione dell'agente conversazionale

L'agente viene creato nella parte 2 di questo lab.

12. Esegui la pulizia

Se prevedi di completare la parte 2 di questo lab, salta questo passaggio, perché il progetto corrente verrà eliminato.

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo post, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Gestisci risorse.
2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

13. Complimenti

Complimenti! Hai eseguito correttamente una ricerca di somiglianze utilizzando AlloyDB, pgvector e Vector Search. Combinando le funzionalità di AlloyDB, Vertex AI e Vector Search, abbiamo fatto un enorme passo avanti nel rendere le ricerche contestuali e vettoriali accessibili, efficienti e realmente basate sul significato. La parte successiva di questo lab illustra i passaggi per la creazione dell'agente.