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 vettoriale per consigliare posizioni di yoga.

Nel codelab, seguirai un approccio passo passo come segue:

1. Utilizza un set di dati esistente di Hugging Face di pose di yoga (formato JSON).
2. Migliora il set di dati con una descrizione di campo aggiuntiva che utilizza Gemini per generare descrizioni per ciascuna delle pose.
3. Utilizza Langchain per creare un documento, utilizza l'integrazione di Firestore Langchain per creare la raccolta e gli incorporamenti in Firestore.
4. Crea un indice composto in Firestore per consentire la ricerca vettoriale.
5. Utilizza la ricerca vettoriale 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 di yoga.

Cosa imparerai a fare

• Come utilizzare Gemini per generare contenuti di testo e, nel contesto di questo codelab, generare descrizioni per le posizioni di yoga
• Come utilizzare Langchain Document Loader per Firestore per caricare record da un set di dati avanzato da Hugging Face in Firestore insieme ai vector embedding
• 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 fatturazione abilitata

Questo codelab, progettato per sviluppatori di tutti i livelli (inclusi i principianti), utilizza Python nella sua applicazione di esempio. Tuttavia, non è necessaria la conoscenza di Python 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 è 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 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

Se il comando viene eseguito correttamente, dovresti visualizzare un messaggio simile a quello mostrato di seguito:

Operation "operations/..." finished successfully.

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.

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 sia in Cloud Shell, esegui questo comando dalla tua 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 visualizzarla 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 e dovresti visualizzare 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 per project_id e location in base a ciò che hai selezionato durante la creazione del progetto Google Cloud e della regione del database Firestore. Idealmente, vorremmo che i valori di location fossero 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, ovviamente, 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.

L'ultimo passaggio consiste nel creare un ambiente Python che utilizzeremo localmente con tutte le dipendenze Python configurate. Dai un'occhiata al file pyproject.toml che contiene i dettagli, i cui contenuti sono mostrati 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 nella versione requirements.txt.. In sintesi, dobbiamo creare un ambiente virtuale Python con le dipendenze del pacchetto Python in requirements.txt da installare nell'ambiente virtuale. Per farlo, vai a Command Palette (Ctrl+Maiusc+P) in Cloud Shell IDE 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, dobbiamo attivarlo con il seguente comando

source .venv/bin/activate

Dovresti vedere (.venv) nella console. Ad esempio -> (.venv) yourusername@cloudshell:

Ottimo. Ora siamo pronti 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.

Inizializzazione del database Firestore

Visita la pagina Firestore nella console Cloud.

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

• Modalità Firestore: Native.
• Seleziona Tipo di località come Region e seleziona la località us-central1 per la regione.
• Per le regole di sicurezza, scegli Test rules.
• Crea il database.

Nella sezione successiva, prepareremo il terreno per la creazione di una raccolta denominata poses nel nostro database Firestore predefinito. Questa raccolta conterrà dati di esempio (documenti) o informazioni sulle posizioni di 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 del database utilizzando la console Firebase.

In questo modo si completa la sezione per la configurazione del database Firestore.

4. Prepara il set di dati Pose di yoga

Il nostro primo compito è preparare il set di dati Yoga Poses che utilizzeremo per l'applicazione. Inizieremo con un set di dati Hugging Face esistente e lo miglioreremo con ulteriori informazioni.

Dai un'occhiata al set di dati di Hugging Face per le posizioni di yoga. Tieni presente che, sebbene questo codelab utilizzi 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 l'abbiamo fornito. Questo file si chiama yoga_poses_alldata.json e si trova nella cartella /data.

Mostreremo l'intera procedura di generazione delle descrizioni e, infine, degli incorporamenti su un sottoinsieme più piccolo di alcuni record, in modo che tu possa familiarizzare con la procedura.

Vai al file data/yoga_poses.json in Cloud Shell Editor e dai un'occhiata all'elenco degli oggetti JSON, dove ogni oggetto JSON rappresenta una posizione di yoga. Abbiamo un totale di tre record e di seguito è mostrato 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"]
 }

Ora è un'ottima opportunità per presentare Gemini e mostrare come possiamo utilizzare il modello predefinito stesso per generare un campo description.

Nell'editor di Cloud Shell, vai al file generate-descriptions.py. I contenuti di questo file sono mostrati 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 di 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(), vedrai che richiama la funzione add_descriptions_to_json e fornisce 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. Invoca la funzione generate_description che crea un prompt e poi invoca la classe del modello Langchain VertexAI per ottenere il testo della risposta.
5. Questo testo di risposta viene quindi aggiunto all'oggetto JSON.
6. L'elenco JSON aggiornato degli oggetti viene quindi scritto nel file di destinazione.

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

python generate-descriptions.py

Se ti viene richiesta un'autorizzazione, forniscila.

Vedrai che l'applicazione inizia l'esecuzione. Abbiamo aggiunto un ritardo di 30 secondi tra i record per evitare eventuali quote di limite di frequenza che potrebbero essere presenti nei nuovi account Google Cloud, quindi ti invitiamo a pazientare.

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

Una volta migliorati tutti e tre i record con la chiamata a Gemini, verrà generato un file data/yoga_poses_with_description.json. Puoi dare un'occhiata.

Ora abbiamo il file di dati e il passaggio successivo consiste nel capire come popolare un database Firestore con questo file, insieme alla generazione di incorporamenti.

5. Importa i dati in Firestore e genera vector embedding

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

Utilizzeremo i componenti Langchain Firestore per implementare la procedura descritta sopra.

Ecco i passaggi da seguire:

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 dei metadati conterrà l'intero oggetto JSON con attributi come name, description, sanskrit_name e così via. page_content sarà una stringa di testo che sarà la concatenazione di alcuni campi.
2. Una volta che abbiamo un elenco di oggetti Document, utilizzeremo la classe Langchain FirestoreVectorStore e in particolare il metodo from_documents con questo elenco di documenti, un nome di raccolta (utilizziamo la variabile TEST_COLLECTION che punta a test-poses), una classe Vertex AI Embedding e i dettagli di connessione Firestore (nome PROJECT_ID e DATABASE). In questo modo verrà creata la raccolta e verrà generato anche un campo embedding per ciascuno degli attributi.

Di seguito è riportato il codice per import-data.py (alcune 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) ed esegui il seguente comando:

python import-data.py

Se tutto va bene, dovresti visualizzare un messaggio simile a quello riportato di seguito:

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 incorporamenti sono stati generati, visita la pagina Firestore nella console Cloud.

Fai clic sul database (predefinito). Dovresti visualizzare la raccolta test-poses e più documenti al suo interno. Ogni documento è una posizione yoga.

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

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

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

Ora creeremo la raccolta poses, che è un elenco completo di 160 posizioni di yoga, per le quali abbiamo generato un file di importazione del database che puoi importare direttamente. Questa operazione viene eseguita per risparmiare tempo nel lab. La procedura per generare il database contenente la descrizione e gli incorporamenti è 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 copiarvi l'esportazione del database che abbiamo preparato 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 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 e, una volta pronta, potrai 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:

In questo modo viene completata la creazione della raccolta Firestore che utilizzeremo nella nostra applicazione.

7. Esegui la ricerca di similarità vettoriale in Firestore

Per eseguire la ricerca di similarità vettoriale, prendiamo in considerazione la query dell'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, mostrata di seguito. A livello generale, crea una classe di incorporamento che verrà utilizzata per generare l'incorporamento per la query dell'utente. Poi utilizza la classe FirestoreVectorStore per richiamare la 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 eseguire questa operazione con alcuni esempi di query, devi prima generare un indice composto Firestore, necessario per l'esecuzione delle query di ricerca. Se esegui l'applicazione senza creare l'indice, verrà visualizzato un errore che indica che devi prima creare l'indice, insieme al comando per farlo.

Il comando gcloud per creare l'indice composito è mostrato di seguito:

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 richiede alcuni minuti perché nel database sono presenti più di 150 record. Una volta completata, puoi visualizzare l'indice tramite il comando mostrato di seguito:

gcloud firestore indexes composite list

Dovresti vedere l'indice che hai appena creato nell'elenco.

Prova subito il seguente comando:

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

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

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 tutto funziona, abbiamo capito come utilizzare il database vettoriale Firestore per caricare record, generare incorporamenti ed eseguire una ricerca di somiglianza vettoriale. Ora possiamo creare un'applicazione web che integrerà la ricerca vettoriale in un front-end web.

8. L'applicazione web

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

Ti consigliamo di dare un'occhiata a entrambi i file. Inizia con il file main.py che contiene il gestore /search, che accetta il prompt passato dal file HTML index.html del front-end. Viene quindi richiamato il metodo di ricerca, che esegue la ricerca di similarità vettoriale esaminata nella sezione precedente.

La risposta viene quindi inviata di nuovo a index.html con l'elenco dei suggerimenti. index.html mostra quindi i suggerimenti come schede diverse.

Esegui l'applicazione localmente

Avvia una nuova finestra del terminale (Ctrl+Maiusc+C) o una finestra del terminale esistente ed esegui il comando seguente:

python main.py

Di seguito è riportato un esempio di esecuzione:

 * 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 che l'applicazione è in esecuzione, visita l'URL della home page facendo clic sul pulsante Anteprima web mostrato di seguito:

Dovrebbe mostrare il file index.html pubblicato come mostrato di seguito:

Fornisci una query di esempio (ad esempio : Provide me some exercises for back pain relief) e fai clic sul pulsante Search. In questo modo dovresti recuperare alcuni consigli dal database. Vedrai anche un pulsante Play Audio, che genererà un flusso audio basato sulla descrizione, che potrai ascoltare direttamente.

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

Il passaggio finale sarà 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. Questi sono i 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. Potrebbe anche esserti chiesto di abilitare le API Google Cloud e di dare la tua approvazione per varie autorizzazioni.

Il completamento della procedura di deployment richiede circa 5-7 minuti, quindi ti invitiamo ad avere pazienza.

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

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 deve 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).

In questo modo, lo sviluppo e il deployment della nostra applicazione web di consigli sulle posizioni di yoga su Cloud Run sono completati.

10. Complimenti

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

Documentazione di riferimento

• Firestore
• Firestore - Search with Vector Embeddings
• Gestire gli indici in Firestore
• Cloud Run
• Langchain Document Loader per Firestore
• Langchain Vector Store per Firestore