Codelab - Crea un'app di consigli contestuali sulle posizioni yoga con Firestore, Vector Search, Langchain e Gemini (versione Python)

1. Introduzione

In questo codelab, creerai un'applicazione che utilizza la ricerca di vettori per consigliare posizioni yoga.

Nel codelab, utilizzerai un approccio passo passo come segue:

1. Utilizza un set di dati Hugging Face esistente di posizioni yoga (formato JSON).
2. Migliora il set di dati con una descrizione del campo aggiuntiva che utilizza Gemini per generare descrizioni per ciascuna delle pose.
3. Utilizza Langchain per creare un documento, utilizza l'integrazione di Langchain di Firestore per creare la raccolta e gli embedding in Firestore.
4. Crea un indice composto in Firestore per consentire la ricerca vettoriale.
5. Utilizza la ricerca di vettori in un'applicazione Flask che riunisce tutto, come mostrato di seguito:

Attività previste

• Progetta, crea ed esegui il deployment di un'applicazione web che utilizza la Ricerca vettoriale per consigliare posizioni yoga.

Cosa imparerai a fare

• Come utilizzare Gemini per generare contenuti di testo e, nel contesto di questo codelab, generare descrizioni per le posizioni yoga
• Come utilizzare Langchain Document Loader per Firestore per caricare in Firestore i record di un set di dati avanzato di Hugging Face insieme agli incorporamenti vettoriali
• Come utilizzare Langchain Vector Store per Firestore per cercare dati in base a una query in linguaggio naturale
• Come utilizzare l'API Google Cloud Text to Speech per generare contenuti audio

Che cosa ti serve

• Browser web Chrome
• Un account Gmail
• Un progetto Cloud con la fatturazione abilitata

Questo codelab, progettato per sviluppatori di tutti i livelli (inclusi i principianti), utilizza Python nella sua applicazione di esempio. Tuttavia, la conoscenza di Python non è necessaria per comprendere i concetti presentati.

2. 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 è attivata 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 connesso a Cloud Shell, verifica di aver già eseguito l'autenticazione e che il progetto sia impostato sul tuo ID progetto utilizzando il seguente comando:

gcloud auth list

5. Esegui il seguente 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 tramite il comando mostrato di seguito. L'operazione potrebbe richiedere alcuni minuti.

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

Al termine dell'esecuzione del comando, dovresti visualizzare un messaggio simile a quello mostrato di seguito:

Operation "operations/..." finished successfully.

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

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

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

Clona il repository e configura le impostazioni dell'ambiente

Il passaggio successivo consiste nel clonare il repository di esempio a cui faremo riferimento nel resto del codelab. Supponendo che tu stia utilizzando Cloud Shell, dai il seguente comando dalla home directory:

git clone https://github.com/rominirani/yoga-poses-recommender-python

Per avviare l'editor, fai clic su Apri editor nella barra degli strumenti della finestra di Cloud Shell. Fai clic sulla barra dei menu nell'angolo in alto a sinistra e seleziona File → Apri cartella come mostrato di seguito:

Seleziona la cartella yoga-poses-recommender-python e dovresti visualizzare la cartella aperta con i seguenti file, come mostrato di seguito:

Ora dobbiamo configurare le variabili di ambiente che utilizzeremo. Fai clic sul file config.template.yaml. Dovresti vedere i contenuti come mostrato di seguito:

project_id: your-project-id
location: us-central1
gemini_model_name: gemini-1.5-flash-002
embedding_model_name: text-embedding-004
image_generation_model_name: imagen-3.0-fast-generate-002
database: (default)
collection: poses
test_collection: test-poses
top_k: "3"

Aggiorna i valori di project_id e location in base a quanto selezionato durante la creazione del progetto Google Cloud e della regione del database Firestore. Idealmente, i valori di location dovrebbero essere gli stessi per il progetto Google Cloud e il database Firestore, ad esempio us-central1.

Ai fini di questo codelab, utilizzeremo i valori preconfigurati, ad eccezione di project_id e location, che devi impostare in base alla tua configurazione.

Salva questo file come config.yaml nella stessa cartella del file config.template.yaml.

Il passaggio finale consiste nel creare un ambiente Python da utilizzare localmente con tutte le dipendenze Python configurate per noi. Dai un'occhiata al file pyproject.toml che contiene i dettagli, i cui contenuti sono riportati di seguito:

dependencies = [
    "datasets>=3.2.0",
    "flask>=3.1.0",
    "google-cloud-aiplatform>=1.78.0",
    "google-cloud-texttospeech>=2.24.0",
    "langchain-community>=0.3.15",
    "langchain-core>=0.3.31",
    "langchain-google-community>=2.0.4",
    "langchain-google-firestore>=0.5.0",
    "langchain-google-vertexai>=2.0.7",
    "pydantic-settings>=2.7.1",
    "pyyaml>=6.0.2",
    "tenacity>=9.0.0",
]

Queste dipendenze sono già bloccate in base alla versione in requirements.txt.. In sintesi, dobbiamo creare un ambiente Python virtuale con le dipendenze dei pacchetti Python in requirements.txt da installare nell'ambiente virtuale. Per farlo, vai a Command Palette (Ctrl+Maiusc+P) nell'IDE Cloud Shell e digita Python: Create Environment. Segui i passaggi successivi per selezionare un file Virtual Environment(venv), Python 3.x interpreter e requirements.txt.

Una volta creato l'ambiente, dovremo attivarlo con il seguente comando

source .venv/bin/activate

Nella console dovresti vedere (.venv). Ad esempio -> (.venv) yourusername@cloudshell:

Ottimo. Ora è tutto pronto per passare alla configurazione del database Firestore.

3. Configura Firestore

Cloud Firestore è un database di documenti serverless completamente gestito che utilizzeremo come backend per i dati della nostra applicazione. I dati in Cloud Firestore sono strutturati in raccolte di documenti.

Inizialezzazione del database Firestore

Visita la pagina Firestore nella console Cloud.

Se non hai mai inizializzato un database Firestore nel progetto, crea il database default facendo clic su Create Database. Durante la creazione del database, utilizza i seguenti valori:

• Modalità Firestore: Native.
• Posizione: utilizza le impostazioni di geolocalizzazione predefinite.
• Per le regole di sicurezza, scegli Test rules.
• Crea il database.

Nella sezione successiva, prepareremo le basi per creare una raccolta denominata poses nel nostro database Firestore predefinito. Questa raccolta conterrà dati di esempio (documenti) o informazioni sulle posizioni yoga, che utilizzeremo nella nostra applicazione.

Tieni presente che si tratta dello stesso Firestore che conosci e apprezzi se utilizzi Firebase. Infatti, puoi accedere alla stessa istanza di database utilizzando la Console Firebase.

Questa è la fine della sezione relativa alla configurazione del database Firestore.

4. Prepara il set di dati sulle posizioni yoga

Il nostro primo compito è preparare il set di dati sulle posizioni yoga che utilizzeremo per l'applicazione. Inizieremo con un set di dati Hugging Face esistente e lo miglioreremo con informazioni aggiuntive.

Consulta il set di dati Hugging Face per le posizioni yoga. Tieni presente che, anche se questo codelab utilizza uno dei set di dati, puoi utilizzare qualsiasi altro set di dati e seguire le stesse tecniche dimostrate per migliorarlo.

Se andiamo alla sezione Files and versions, possiamo ottenere il file di dati JSON per tutte le pose.

Abbiamo scaricato il file yoga_poses.json e te lo abbiamo fornito. Questo file si chiama yoga_poses_alldata.json e si trova nella cartella /data.

Ti mostreremo l'intera procedura di generazione delle descrizioni e, infine, degli embedding su un sottoinsieme più piccolo di alcuni record, in modo che tu possa acquisire familiarità con la procedura.

Vai al file data/yoga_poses.json nell'editor Cloud Shell e dai un'occhiata all'elenco di oggetti JSON, in cui ogni oggetto JSON rappresenta una posa yoga. Abbiamo un totale di 3 record e di seguito è riportato un record di esempio:

{
   "name": "Big Toe Pose",
   "sanskrit_name": "Padangusthasana",
   "photo_url": "https://pocketyoga.com/assets/images/full/ForwardBendBigToe.png",
   "expertise_level": "Beginner",
   "pose_type": ["Standing", "Forward Bend"]
 }

Questa è un'ottima opportunità per presentarti Gemini e come possiamo utilizzare il modello predefinito per generare un campo description.

Nell'editor di Cloud Shell, vai al file generate-descriptions.py. I contenuti di questo file sono riportati di seguito:

import json
import time
import logging
import vertexai
from langchain_google_vertexai import VertexAI
from tenacity import retry, stop_after_attempt, wait_exponential
from settings import get_settings

settings = get_settings()
logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
)
# Initialize Vertex AI SDK
vertexai.init(project=settings.project_id, location=settings.location)
logging.info("Done Initializing Vertex AI SDK")


@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=4, max=10),
)
def generate_description(pose_name, sanskrit_name, expertise_level, pose_types):
    """Generates a description for a yoga pose using the Gemini API."""

    prompt = f"""
    Generate a concise description (max 50 words) for the yoga pose: {pose_name}
    Also known as: {sanskrit_name}
    Expertise Level: {expertise_level}
    Pose Type: {", ".join(pose_types)}

    Include key benefits and any important alignment cues.
    """
    try:
        model = VertexAI(model_name=settings.gemini_model_name, verbose=True)
        response = model.invoke(prompt)
        return response
    except Exception as e:
        logging.info(f"Error generating description for {pose_name}: {e}")
        return ""


def add_descriptions_to_json(input_file, output_file):
    """Loads JSON data, adds descriptions, and saves the updated data."""

    with open(input_file, "r") as f:
        yoga_poses = json.load(f)

    total_poses = len(yoga_poses)
    processed_count = 0

    for pose in yoga_poses:
        if pose["name"] != " Pose":
            start_time = time.time()  # Record start time
            pose["description"] = generate_description(
                pose["name"],
                pose["sanskrit_name"],
                pose["expertise_level"],
                pose["pose_type"],
            )
            end_time = time.time()  # Record end time

            processed_count += 1
            end_time = time.time()  # Record end time
            time_taken = end_time - start_time
            logging.info(
                f"Processed: {processed_count}/{total_poses} - {pose['name']} ({time_taken:.2f} seconds)"
            )

        else:
            pose["description"] = ""
            processed_count += 1
            logging.info(
                f"Processed: {processed_count}/{total_poses} - {pose['name']} ({time_taken:.2f} seconds)"
            )
        # Adding a delay to avoid rate limit
        time.sleep(30)

    with open(output_file, "w") as f:
        json.dump(yoga_poses, f, indent=2)


def main():
    # File paths
    input_file = "./data/yoga_poses.json"
    output_file = "./data/yoga_poses_with_descriptions.json"

    # Add descriptions and save the updated JSON
    add_descriptions_to_json(input_file, output_file)


if __name__ == "__main__":
    main()

Questa applicazione aggiungerà un nuovo campo description a ogni record JSON della posa yoga. Otterrà la descrizione tramite una chiamata al modello Gemini, a cui forniremo il prompt necessario. Il campo viene aggiunto al file JSON e il nuovo file viene scritto nel file data/yoga_poses_with_descriptions.json.

Vediamo i passaggi principali:

1. Nella funzione main(), noterai che viene richiamata la funzione add_descriptions_to_json e vengono forniti il file di input e il file di output previsti.
2. La funzione add_descriptions_to_json esegue le seguenti operazioni per ogni record JSON, ovvero le informazioni del post di yoga:
3. Estrae pose_name, sanskrit_name, expertise_level e pose_types.
4. Richiama la funzione generate_description che crea un prompt e poi la classe del modello Langchain VertexAI per ottenere il testo della risposta.
5. Questo testo di risposta viene poi aggiunto all'oggetto JSON.
6. L'elenco JSON aggiornato degli oggetti viene poi scritto nel file di destinazione.

Eseguiamo questa applicazione. Avvia una nuova finestra del terminale (Ctrl+Maiusc+C) e dai il seguente comando:

python generate-descriptions.py

Se ti viene richiesta un'autorizzazione, forniscila.

L'applicazione inizierà a essere eseguita. Abbiamo aggiunto un ritardo di 30 secondi tra i record per evitare eventuali quote di limite di frequenza nei nuovi account Google Cloud, quindi ti invitiamo a pazientare.

Di seguito è riportata un'esecuzione di esempio in corso:

Una volta migliorati tutti e 3 i record con la chiamata di Gemini, verrà generato un file data/yoga_poses_with_description.json. Dai un'occhiata.

Ora abbiamo il nostro file di dati e il passaggio successivo è capire come compilare un database Firestore con i dati e generare gli embedding.

5. Importa i dati in Firestore e genera embedding di vettori

Abbiamo il file data/yoga_poses_with_description.json e ora dobbiamo compilare il database Firestore con questo file e, soprattutto, generare gli embedding vettoriali per ciascuno dei record. Gli embedding vettoriali saranno utili in un secondo momento quando dovremo eseguire una ricerca di similarità con la query dell'utente fornita in linguaggio naturale.

Per implementare la procedura precedente, utilizzeremo i componenti Firestore di Langchain.

I passaggi da seguire sono i seguenti:

1. Convertiremo l'elenco di oggetti JSON in un elenco di oggetti Langchain Document. Ogni documento avrà due attributi: page_content e metadata. L'oggetto metadati conterrà l'intero oggetto JSON con attributi come name, description, sanskrit_name e così via. page_content sarà una stringa che sarà una concatenazione di alcuni campi.
2. Una volta ottenuto un elenco di oggetti Document, utilizzeremo la classe Langchain FirestoreVectorStore e, in particolare, il metodo from_documents con questo elenco di documenti, un nome della raccolta (utilizziamo la variabile TEST_COLLECTION che punta a test-poses), una classe di embedding Vertex AI e i dettagli di connessione di Firestore (nome PROJECT_ID e DATABASE). Verrà creata la raccolta e verrà generato anche un campo embedding per ciascuno degli attributi.

Di seguito è riportato il codice per import-data.py (parti del codice sono state troncate per brevità):

... 

def create_langchain_documents(poses):
   """Creates a list of Langchain Documents from a list of poses."""
   documents = []
   for pose in poses:
       # Convert the pose to a string representation for page_content
       page_content = (
           f"name: {pose.get('name', '')}\n"
           f"description: {pose.get('description', '')}\n"
           f"sanskrit_name: {pose.get('sanskrit_name', '')}\n"
           f"expertise_level: {pose.get('expertise_level', 'N/A')}\n"
           f"pose_type: {pose.get('pose_type', 'N/A')}\n"
       ).strip()
       # The metadata will be the whole pose
       metadata = pose

       document = Document(page_content=page_content, metadata=metadata)
       documents.append(document)
   logging.info(f"Created {len(documents)} Langchain documents.")
   return documents

def main():
    all_poses = load_yoga_poses_data_from_local_file(
        "./data/yoga_poses_with_descriptions.json"
    )
    documents = create_langchain_documents(all_poses)
    logging.info(
        f"Successfully created langchain documents. Total documents: {len(documents)}"
    )

    embedding = VertexAIEmbeddings(
        model_name=settings.embedding_model_name,
        project=settings.project_id,
        location=settings.location,
    )

    client = firestore.Client(project=settings.project_id, database=settings.database)

    vector_store = FirestoreVectorStore.from_documents(
        client=client,
        collection=settings.test_collection,
        documents=documents,
        embedding=embedding,
    )
    logging.info("Added documents to the vector store.")


if __name__ == "__main__":
    main()

Eseguiamo questa applicazione. Avvia una nuova finestra del terminale (Ctrl+Maiusc+C) e dai il seguente comando:

python import-data.py

Se tutto va bene, dovresti visualizzare un messaggio simile al seguente:

2025-01-21 14:50:06,479 - INFO - Added documents to the vector store.

Per verificare se i record sono stati inseriti correttamente e se gli embedding sono stati generati, visita la pagina Firestore nella console Cloud.

Fai clic sul database (predefinito), che dovrebbe mostrare la raccolta test-poses e più documenti al suo interno. Ogni documento è una posa yoga.

Fai clic su uno dei documenti per esaminare i campi. Oltre ai campi che abbiamo importato, troverai anche il campo embedding, un campo Vettore che è stato generato automaticamente per te tramite la classe Langchain VertexAIEmbeddings che abbiamo utilizzato, in cui abbiamo fornito il modello di embedding Vertex AI text-embedding-004.

Ora che abbiamo caricato i record nel database Firestore con gli incorporamenti, possiamo passare al passaggio successivo e scoprire come eseguire la ricerca di somiglianza vettoriale in Firestore.

6. Importa le pose yoga complete nella raccolta del database Firestore

Ora creeremo la raccolta poses, ovvero un elenco completo di 160 posizioni yoga, per la quale abbiamo generato un file di importazione del database che puoi importare direttamente. Questo viene fatto per risparmiare tempo nel lab. La procedura per generare il database contenente la descrizione e gli embedding è la stessa che abbiamo visto nella sezione precedente.

Importa il database seguendo i passaggi riportati di seguito:

1. Crea un bucket nel tuo progetto con il comando gsutil riportato di seguito. Sostituisci la variabile <PROJECT_ID> nel comando seguente con il tuo ID progetto Google Cloud.

gsutil mb -l us-central1 gs://<PROJECT_ID>-my-bucket

2. Ora che il bucket è stato creato, dobbiamo copiare l'esportazione del database che abbiamo preparato in questo bucket prima di poterla importare nel database Firebase. Utilizza il comando riportato di seguito:

gsutil cp -r gs://yoga-database-firestore-export-bucket/2025-01-27T05:11:02_62615  gs://<PROJECT_ID>-my-bucket

Ora che abbiamo i dati da importare, possiamo passare al passaggio finale dell'importazione dei dati nel database Firebase (default) che abbiamo creato.

3. Utilizza il comando gcloud riportato di seguito:

gcloud firestore import gs://<PROJECT_ID>-my-bucket/2025-01-27T05:11:02_62615

L'importazione richiederà alcuni secondi. Una volta completata, puoi convalidare il database Firestore e la raccolta visitando la pagina https://console.cloud.google.com/firestore/databases, selezionando il database default e la raccolta poses come mostrato di seguito:

La creazione della raccolta Firestore che utilizzeremo nella nostra applicazione è completata.

7. Eseguire una ricerca sulla similarità vettoriale in Firestore

Per eseguire la ricerca sulla similarità vettoriale, acquisiremo la query dall'utente. Un esempio di questa query può essere "Suggest me some exercises to relieve back pain".

Dai un'occhiata al file search-data.py. La funzione principale da esaminare è la funzione di ricerca, che è mostrata di seguito. A un livello generale, crea una classe di embedding che verrà utilizzata per generare l'embedding per la query dell'utente. Poi utilizza la classe FirestoreVectorStore per richiamare la sua funzione similarity_search.

def search(query: str):
    """Executes Firestore Vector Similarity Search"""
    embedding = VertexAIEmbeddings(
        model_name=settings.embedding_model_name,
        project=settings.project_id,
        location=settings.location,
    )

    client = firestore.Client(project=settings.project_id, database=settings.database)

    vector_store = FirestoreVectorStore(
        client=client, collection=settings.collection, embedding_service=embedding
    )

    logging.info(f"Now executing query: {query}")
    results: list[Document] = vector_store.similarity_search(
        query=query, k=int(settings.top_k), include_metadata=True
    )
    for result in results:
        print(result.page_content)

Prima di eseguirlo con alcuni esempi di query, devi prima generare un indice composto Firestore, necessario per il buon esito delle query di ricerca. Se esegui l'applicazione senza creare l'indice, viene visualizzato un errore che indica che devi prima creare l'indice, insieme al comando per creare l'indice.

Di seguito è riportato il comando gcloud per creare l'indice composito:

gcloud firestore indexes composite create --project=<YOUR_PROJECT_ID> --collection-group=poses --query-scope=COLLECTION --field-config=vector-config='{"dimension":"768","flat": "{}"}',field-path=embedding

Il completamento dell'indice richiederà alcuni minuti perché nel database sono presenti più di 150 record. Al termine, puoi visualizzare l'indice tramite il comando mostrato di seguito:

gcloud firestore indexes composite list

Nell'elenco dovresti vedere l'indice che hai appena creato.

Prova subito il seguente comando:

python search-data.py --prompt "Recommend me some exercises for back pain relief"

Dovresti ricevere alcuni consigli. Di seguito è riportata un'esecuzione di esempio:

2025-01-21 15:48:51,282 - INFO - Now executing query: Recommend me some exercises for back pain relief
name: Supine Spinal Twist Pose
description: A gentle supine twist (Supta Matsyendrasana), great for beginners.  Releases spinal tension, improves digestion, and calms the nervous system.  Keep shoulders flat on the floor and lengthen the spine.

sanskrit_name: Supta Matsyendrasana
expertise_level: Beginner
pose_type: ['Supine', 'Twist']
name: Cow Pose
description: Cow Pose (Bitilasana) is a gentle backbend, stretching the chest, shoulders, and abdomen.  Maintain a neutral spine, lengthen the tailbone, and avoid hyperextension.  Benefits include improved posture and stress relief.

sanskrit_name: Bitilasana
expertise_level: Beginner
pose_type: ['Arm Leg Support', 'Back Bend']
name: Locust I Pose
description: Locust Pose I (Shalabhasana A) strengthens the back, glutes, and shoulders.  Lie prone, lift chest and legs simultaneously, engaging back muscles.  Keep hips grounded and gaze slightly forward.

sanskrit_name: Shalabhasana A
expertise_level: Intermediate
pose_type: ['Prone', 'Back Bend']

Una volta che hai completato questa operazione, avrai capito come utilizzare il database vettoriale Firestore per caricare record, generare embedding ed eseguire una ricerca di somiglianza vettoriale. Ora possiamo creare un'applicazione web che integri la ricerca di vettori in un front-end web.

8. L'applicazione web

L'applicazione web Python Flask è disponibile nel file main.py e il file HTML frontend è presente in templates/index.html.

Ti consigliamo di dare un'occhiata a entrambi i file. Inizia con il file main.py contenente l'handler /search, che prende il prompt passato dal file HTML index.html del front-end. Viene quindi invocato il metodo di ricerca, che esegue la ricerca di somiglianza di vettori che abbiamo esaminato nella sezione precedente.

La risposta viene quindi inviata al index.html con l'elenco dei consigli. index.html mostra quindi i consigli sotto forma di schede diverse.

Eseguire l'applicazione localmente

Avvia una nuova finestra del terminale (Ctrl+Maiusc+C) o qualsiasi finestra del terminale esistente e dai il seguente comando:

python main.py

Di seguito è riportata un'esecuzione di esempio:

 * Serving Flask app 'main'
 * Debug mode: on
2025-01-21 16:02:37,473 - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:8080
 * Running on http://10.88.0.4:8080
2025-01-21 16:02:37,473 - INFO - Press CTRL+C to quit
2025-01-21 16:02:37,474 - INFO -  * Restarting with stat
2025-01-21 16:02:41,462 - WARNING -  * Debugger is active!
2025-01-21 16:02:41,484 - INFO -  * Debugger PIN: 440-653-555

Una volta completata la configurazione, visita l'URL di casa dell'applicazione facendo clic sul pulsante Anteprima web mostrato di seguito:

Dovresti vedere il file index.html pubblicato come mostrato di seguito:

Fornisci una query di esempio (ad es. Provide me some exercises for back pain relief) e fai clic sul pulsante Search. Dovresti recuperare alcuni consigli dal database. Vedrai anche un pulsante Play Audio che genera uno stream audio basato sulla descrizione, che puoi ascoltare direttamente.

9. (Facoltativo) Eseguire il deployment in Google Cloud Run

Il passaggio finale consisterà nell'eseguire il deployment di questa applicazione in Google Cloud Run. Il comando di deployment è mostrato di seguito. Prima di eseguirlo, assicurati di sostituire i valori della variabile (<<YOUR_PROJECT_ID>>) con quelli specifici del tuo progetto. Si tratta di valori che potrai recuperare dal file config.yaml.

gcloud run deploy yogaposes --source . \
  --port=8080 \
  --allow-unauthenticated \
  --region=us-central1 \
  --platform=managed  \
  --project=<<YOUR_PROJECT_ID>> \
  --env-vars-file=config.yaml

Esegui il comando riportato sopra dalla cartella principale dell'applicazione. Ti potrebbe anche essere chiesto di abilitare le API Google Cloud, quindi conferma le varie autorizzazioni.

Il completamento del processo di deployment richiede circa 5-7 minuti, quindi attendi.

Una volta eseguito il deployment, l'output del deployment fornirà l'URL del servizio Cloud Run. Il formato sarà il seguente:

Service URL: https://yogaposes-<<UNIQUEID>.us-central1.run.app

Visita l'URL pubblico e dovresti vedere la stessa applicazione web di cui è stato eseguito il deployment e che è in esecuzione correttamente.

Puoi anche visitare Cloud Run dalla console Google Cloud e visualizzare l'elenco dei servizi in Cloud Run. Il servizio yogaposes dovrebbe essere uno dei servizi (se non l'unico) elencati.

Puoi visualizzare i dettagli del servizio, come URL, configurazioni, log e altro ancora, facendo clic sul nome del servizio specifico (yogaposes nel nostro caso).

Lo sviluppo e il deployment della nostra applicazione web di consigli sulle posizioni yoga su Cloud Run sono stati completati.

10. Complimenti

Congratulazioni, hai creato correttamente un'applicazione che carica un set di dati in Firestore, genera gli embedding ed esegue una ricerca di somiglianza vettoriale in base alla query degli utenti.

Documentazione di riferimento

• Firestore
• Firestore - Ricerca con incorporamenti vettoriali
• Gestire gli indici in Firestore
• Cloud Run
• Langchain Document Loader per Firestore
• Langchain Vector Store per Firestore