Atelier de programmation : Créer une application de recommandation de postures de yoga contextuelle avec Firestore, Vector Search, Langchain et Gemini (version Python)

1. Introduction

Dans cet atelier de programmation, vous allez créer une application qui utilise la recherche vectorielle pour recommander des postures de yoga.

Au cours de l'atelier de programmation, vous allez suivre une approche par étapes:

1. Utilisez un ensemble de données Hugging Face existant sur les postures de yoga (format JSON).
2. Améliorez l'ensemble de données avec une description de champ supplémentaire qui utilise Gemini pour générer des descriptions pour chacune des poses.
3. Utilisez Langchain pour créer un document, puis l'intégration Langchain Firestore pour créer la collection et les représentations vectorielles continues dans Firestore.
4. Créez un index composite dans Firestore pour permettre la recherche vectorielle.
5. Utilisez la recherche vectorielle dans une application Flask qui rassemble tout, comme indiqué ci-dessous:

Objectifs de l'atelier

• Concevez, créez et déployez une application Web qui utilise Vector Search pour recommander des postures de yoga.

Points abordés

• Utiliser Gemini pour générer du contenu textuel et, dans le cadre de cet atelier de programmation, générer des descriptions de postures de yoga
• Utiliser le chargeur de documents Langchain pour Firestore pour charger des enregistrements d'un ensemble de données amélioré de Hugging Face dans Firestore avec des représentations vectorielles continues
• Rechercher des données à l'aide d'une requête en langage naturel avec le magasin de vecteurs LangChain pour Firestore
• Utiliser l'API Google Cloud Text-to-Speech pour générer du contenu audio

Prérequis

• Navigateur Web Chrome
• Un compte Gmail
• Un projet Cloud pour lequel la facturation est activée

Cet atelier de programmation, conçu pour les développeurs de tous niveaux (y compris les débutants), utilise Python dans son application exemple. Toutefois, vous n'avez pas besoin de connaître Python pour comprendre les concepts présentés.

2. Avant de commencer

Créer un projet

1. Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet .
3. Vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans Google Cloud et fourni avec bq. Cliquez sur "Activer Cloud Shell" en haut de la console Google Cloud.

4. Une fois connecté à Cloud Shell, vérifiez que vous êtes déjà authentifié et que le projet est défini avec votre ID de projet à l'aide de la commande suivante:

gcloud auth list

5. Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet.

gcloud config list project

6. Si votre projet n'est pas défini, utilisez la commande suivante pour le définir :

gcloud config set project <YOUR_PROJECT_ID>

7. Activez les API requises à l'aide de la commande ci-dessous. Cette opération peut prendre quelques minutes. Veuillez patienter.

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

Si l'exécution de la commande aboutit, un message semblable à celui ci-dessous s'affiche:

Operation "operations/..." finished successfully.

Vous pouvez également rechercher chaque produit dans la console ou utiliser ce lien.

Si une API est manquante, vous pouvez toujours l'activer au cours de l'implémentation.

Consultez la documentation pour connaître les commandes gcloud ainsi que leur utilisation.

Cloner le dépôt et configurer les paramètres de l'environnement

L'étape suivante consiste à cloner l'exemple de dépôt que nous allons référencer dans le reste de l'atelier de programmation. Si vous êtes dans Cloud Shell, exécutez la commande suivante à partir de votre répertoire d'accueil:

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

Pour lancer l'éditeur, cliquez sur "Ouvrir l'éditeur" dans la barre d'outils de la fenêtre Cloud Shell. Cliquez sur la barre de menu en haut à gauche, puis sélectionnez "File" (Fichier) → "Open Folder" (Ouvrir un dossier), comme illustré ci-dessous:

Sélectionnez le dossier yoga-poses-recommender-python. Il devrait s'ouvrir avec les fichiers suivants, comme indiqué ci-dessous:

Nous devons maintenant configurer les variables d'environnement que nous allons utiliser. Cliquez sur le fichier config.template.yaml. Le contenu devrait s'afficher comme indiqué ci-dessous:

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"

Veuillez mettre à jour les valeurs de project_id et de location en fonction de ce que vous avez sélectionné lors de la création du projet Google Cloud et de la région de la base de données Firestore. Idéalement, les valeurs de location doivent être identiques pour le projet Google Cloud et la base de données Firestore, par exemple us-central1.

Pour cet atelier de programmation, nous allons utiliser les valeurs préconfigurées (à l'exception de project_id et location, que vous devez définir en fonction de votre configuration).

Veuillez enregistrer ce fichier sous le nom config.yaml dans le même dossier que le fichier config.template.yaml.

La dernière étape consiste à créer un environnement Python que nous utiliserons localement avec toutes les dépendances Python configurées pour nous. Consultez le fichier pyproject.toml qui contient les détails, dont le contenu est indiqué ci-dessous:

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",
]

Ces dépendances sont déjà verrouillées par version dans requirements.txt.. Pour résumer, nous devons créer un environnement Python virtuel avec les dépendances de paquets Python dans requirements.txt à installer dans l'environnement virtuel. Pour ce faire, accédez à Command Palette (Ctrl+Maj+P) dans l'IDE Cloud Shell, puis saisissez Python: Create Environment. Suivez les étapes suivantes pour sélectionner un Virtual Environment(venv), un Python 3.x interpreter et le fichier requirements.txt.

Une fois l'environnement créé, nous devons l'activer à l'aide de la commande suivante :

source .venv/bin/activate

(.venv) devrait s'afficher dans votre console. Exemple : -> (.venv) yourusername@cloudshell:

Parfait ! Nous sommes maintenant prêts à passer à la configuration de la base de données Firestore.

3. Configurer Firestore

Cloud Firestore est une base de données de documents sans serveur entièrement gérée que nous utiliserons comme backend pour les données de notre application. Les données de Cloud Firestore sont structurées en collections de documents.

Initialisation de la base de données Firestore

Accédez à la page Firestore de Cloud Console.

Si vous n'avez jamais initialisé de base de données Firestore dans le projet, créez la base de données default en cliquant sur Create Database. Lors de la création de la base de données, utilisez les valeurs suivantes:

• Mode Firestore: Native.
• Position: utilisez les paramètres de localisation par défaut.
• Pour les règles de sécurité, sélectionnez Test rules.
• Créez la base de données.

Dans la section suivante, nous allons préparer la création d'une collection nommée poses dans notre base de données Firestore par défaut. Cette collection contiendra des exemples de données (documents) ou des informations sur les postures de yoga, que nous utiliserons ensuite dans notre application.

Notez qu'il s'agit du même Firestore que vous connaissez si vous utilisez Firebase. En fait, vous pouvez accéder à la même instance de base de données à l'aide de la console Firebase.

Vous avez terminé la section sur la configuration de la base de données Firestore.

4. Préparer l'ensemble de données sur les postures de yoga

Notre première tâche consiste à préparer l'ensemble de données sur les postures de yoga que nous utiliserons pour l'application. Nous allons commencer par un ensemble de données Hugging Face existant, puis l'enrichir avec des informations supplémentaires.

Consultez l'ensemble de données Hugging Face pour les postures de yoga. Notez que cet atelier de programmation utilise l'un des ensembles de données, mais que vous pouvez utiliser n'importe quel autre ensemble de données et suivre les mêmes techniques pour l'améliorer.

Si nous accédons à la section Files and versions, nous pouvons obtenir le fichier de données JSON pour toutes les poses.

Nous avons téléchargé le fichier yoga_poses.json et vous l'avons fourni. Ce fichier est nommé yoga_poses_alldata.json et se trouve dans le dossier /data.

Nous allons vous montrer l'ensemble des processus de génération de descriptions et, finalement, de génération des représentations vectorielles continues sur un sous-ensemble plus petit de quelques enregistrements, afin que vous vous familiarisiez avec le processus.

Accédez au fichier data/yoga_poses.json dans l'éditeur Cloud Shell et examinez la liste des objets JSON, où chaque objet JSON représente une posture de yoga. Il y a un total de trois enregistrements, et un exemple d'enregistrement est présenté ci-dessous:

{
   "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"]
 }

C'est l'occasion de vous présenter Gemini et de vous expliquer comment utiliser le modèle par défaut pour générer un champ description.

Dans l'éditeur Cloud Shell, accédez au fichier generate-descriptions.py. Le contenu de ce fichier est affiché ci-dessous:

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()

Cette application ajoutera un nouveau champ description à chaque enregistrement JSON de la pose de yoga. Il obtiendra la description via un appel au modèle Gemini, auquel nous lui fournirons l'invite nécessaire. Le champ est ajouté au fichier JSON, et le nouveau fichier est écrit dans le fichier data/yoga_poses_with_descriptions.json.

Passons en revue les principales étapes:

1. Dans la fonction main(), vous constaterez qu'elle appelle la fonction add_descriptions_to_json et fournit le fichier d'entrée et le fichier de sortie attendus.
2. La fonction add_descriptions_to_json effectue les opérations suivantes pour chaque enregistrement JSON, c'est-à-dire les informations sur le post sur le yoga:
3. Il extrait les pose_name, sanskrit_name, expertise_level et pose_types.
4. Il appelle la fonction generate_description qui crée une requête, puis la classe de modèle Langchain VertexAI pour obtenir le texte de la réponse.
5. Ce texte de réponse est ensuite ajouté à l'objet JSON.
6. La liste d'objets JSON mise à jour est ensuite écrite dans le fichier de destination.

Exécutons cette application. Ouvrez une nouvelle fenêtre de terminal (Ctrl+Maj+C) et exécutez la commande suivante:

python generate-descriptions.py

Si une autorisation vous est demandée, veuillez la fournir.

Vous constaterez que l'application commence à s'exécuter. Nous avons ajouté un délai de 30 secondes entre les enregistrements pour éviter tout quota de limite de débit qui pourrait s'appliquer aux nouveaux comptes Google Cloud. Veuillez donc patienter.

Voici un exemple d'exécution en cours:

Une fois les trois enregistrements améliorés avec l'appel Gemini, un fichier data/yoga_poses_with_description.json est généré. Vous pouvez y jeter un coup d'œil.

Notre fichier de données est maintenant prêt. L'étape suivante consiste à comprendre comment le renseigner dans une base de données Firestore, ainsi que la génération d'embeddings.

5. Importer des données dans Firestore et générer des représentations vectorielles continues

Nous disposons du fichier data/yoga_poses_with_description.json. Nous devons maintenant l'insérer dans la base de données Firestore et, surtout, générer les représentations vectorielles continues pour chacun des enregistrements. Les embeddings vectoriels seront utiles plus tard, lorsque nous devrons effectuer une recherche de similarité avec la requête utilisateur fournie en langage naturel.

Nous utiliserons les composants Firestore de Langchain pour implémenter le processus ci-dessus.

Pour ce faire, procédez comme suit:

1. Nous allons convertir la liste d'objets JSON en liste d'objets Langchain Document. Chaque document comporte deux attributs: page_content et metadata. L'objet de métadonnées contient l'intégralité de l'objet JSON qui comporte des attributs tels que name, description, sanskrit_name, etc. page_content est une chaîne de texte qui est une concaténation de quelques champs.
2. Une fois que nous aurons une liste d'objets Document, nous utiliserons la classe Langchain FirestoreVectorStore et plus précisément la méthode from_documents avec cette liste de documents, un nom de collection (nous utilisons la variable TEST_COLLECTION qui pointe vers test-poses), une classe d'encapsulation Vertex AI et les informations de connexion Firestore (noms PROJECT_ID et DATABASE). La collection est ainsi créée, et un champ embedding est généré pour chacun des attributs.

Le code de import-data.py est donné ci-dessous (certaines parties du code ont été tronquées par souci de concision):

... 

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()

Exécutons cette application. Ouvrez une nouvelle fenêtre de terminal (Ctrl+Maj+C) et exécutez la commande suivante:

python import-data.py

Si tout se passe bien, un message semblable à celui-ci doit s'afficher:

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

Pour vérifier si les enregistrements ont bien été insérés et si les représentations vectorielles continues ont été générées, accédez à la page Firestore de la console Cloud.

Cliquez sur la base de données (par défaut). La collection test-poses et plusieurs documents sous cette collection devraient s'afficher. Chaque document correspond à une posture de yoga.

Cliquez sur l'un des documents pour examiner les champs. En plus des champs que nous avons importés, vous trouverez également le champ embedding, qui est un champ Vector généré automatiquement pour vous via la classe Langchain VertexAIEmbeddings que nous avons utilisée, dans laquelle nous avons fourni le modèle d'encapsulation Vertex AI text-embedding-004.

Maintenant que les enregistrements ont été importés dans la base de données Firestore avec les représentations vectorielles continues en place, nous pouvons passer à l'étape suivante et voir comment effectuer une recherche de similarité vectorielle dans Firestore.

6. Importer des poses de yoga complètes dans une collection de base de données Firestore

Nous allons maintenant créer la collection poses, qui est une liste complète de 160 postures de yoga, pour laquelle nous avons généré un fichier d'importation de base de données que vous pouvez importer directement. Cela permet de gagner du temps pendant l'atelier. Le processus de génération de la base de données contenant la description et les représentations vectorielles continues est le même que celui que nous avons vu dans la section précédente.

Importez la base de données en suivant les étapes ci-dessous:

1. Créez un bucket dans votre projet à l'aide de la commande gsutil ci-dessous. Remplacez la variable <PROJECT_ID> dans la commande ci-dessous par l'ID de votre projet Google Cloud.

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

2. Maintenant que le bucket est créé, nous devons y copier l'exportation de la base de données que nous avons préparée avant de pouvoir l'importer dans la base de données Firebase. Utilisez la commande ci-dessous:

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

Maintenant que nous avons les données à importer, nous pouvons passer à l'étape finale d'importation des données dans la base de données Firebase (default) que nous avons créée.

3. Utilisez la commande gcloud ci-dessous:

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

L'importation prend quelques secondes. Une fois qu'elle est terminée, vous pouvez valider votre base de données Firestore et la collection en accédant à https://console.cloud.google.com/firestore/databases, en sélectionnant la base de données default et la collection poses, comme indiqué ci-dessous:

La création de la collection Firestore que nous utiliserons dans notre application est terminée.

7. Effectuer une recherche de similarité vectorielle dans Firestore

Pour effectuer une recherche de similarité vectorielle, nous allons récupérer la requête de l'utilisateur. Par exemple, "Suggest me some exercises to relieve back pain".

Examinez le fichier search-data.py. La fonction clé à examiner est la fonction de recherche, qui est présentée ci-dessous. De manière générale, il crée une classe d'embedding qui doit être utilisée pour générer l'embedding de la requête utilisateur. Il utilise ensuite la classe FirestoreVectorStore pour appeler sa fonction 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)

Avant d'exécuter cette requête avec quelques exemples, vous devez d'abord générer un index composite Firestore, qui est nécessaire pour que vos requêtes de recherche aboutissent. Si vous exécutez l'application sans créer l'index, un message d'erreur indiquant que vous devez d'abord créer l'index s'affiche, avec la commande à exécuter pour le créer.

La commande gcloud permettant de créer l'index composite est indiquée ci-dessous:

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

L'indexation prend quelques minutes, car la base de données contient plus de 150 enregistrements. Une fois l'indexation terminée, vous pouvez afficher l'index à l'aide de la commande ci-dessous:

gcloud firestore indexes composite list

L'index que vous venez de créer doit s'afficher dans la liste.

Essayez maintenant la commande suivante:

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

Vous devriez recevoir quelques recommandations. Voici un exemple d'exécution:

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']

Une fois que vous avez terminé, vous savez maintenant comment utiliser la base de données vectorielle Firestore pour importer des enregistrements, générer des représentations vectorielles continues et effectuer une recherche de similarité vectorielle. Nous pouvons maintenant créer une application Web qui intégrera la recherche vectorielle dans un front-end Web.

8. L'application Web

L'application Web Python Flask est disponible dans le fichier main.py, et le fichier HTML du front-end est présent dans le fichier templates/index.html..

Nous vous recommandons de consulter les deux fichiers. Commencez par le fichier main.py qui contient le gestionnaire /search, qui récupère l'invite transmise à partir du fichier HTML index.html du front-end. La méthode de recherche est ensuite appelée, ce qui effectue la recherche de similarité vectorielle que nous avons examinée dans la section précédente.

La réponse est ensuite renvoyée à index.html avec la liste des recommandations. index.html affiche ensuite les recommandations sous forme de fiches différentes.

Exécuter l'application en local

Ouvrez une nouvelle fenêtre de terminal (Ctrl+Maj+C) ou une fenêtre de terminal existante, puis exécutez la commande suivante:

python main.py

Voici un exemple d'exécution:

 * 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

Une fois l'application opérationnelle, accédez à son URL d'accueil en cliquant sur le bouton "Aperçu sur le Web" ci-dessous:

Le fichier index.html diffusé doit s'afficher, comme illustré ci-dessous:

Fournissez un exemple de requête (par exemple, Provide me some exercises for back pain relief) et cliquez sur le bouton Search. Vous devriez ainsi récupérer certaines recommandations dans la base de données. Vous verrez également un bouton Play Audio, qui génère un flux audio basé sur la description, que vous pouvez écouter directement.

9. (Facultatif) Déployer sur Google Cloud Run

La dernière étape consiste à déployer cette application sur Google Cloud Run. La commande de déploiement est affichée ci-dessous. Avant de la déployer, assurez-vous de remplacer les valeurs de la variable (<<YOUR_PROJECT_ID>>) par celles qui sont spécifiques à votre projet. Il s'agit de valeurs que vous pourrez récupérer dans le fichier 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

Exécutez la commande ci-dessus à partir du dossier racine de l'application. Vous serez peut-être également invité à activer les API Google Cloud et à accepter diverses autorisations. Veuillez le faire.

Le processus de déploiement prend environ cinq à sept minutes. Veuillez donc patienter.

Une fois le déploiement terminé, l'URL du service Cloud Run s'affiche dans la sortie du déploiement. Il se présente sous la forme suivante:

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

Accédez à cette URL publique. Vous devriez voir la même application Web déployée et en cours d'exécution.

Vous pouvez également accéder à Cloud Run depuis la console Google Cloud pour afficher la liste des services dans Cloud Run. Le service yogaposes doit figurer dans la liste (s'il n'est pas le seul).

Vous pouvez afficher les détails du service, tels que l'URL, les configurations, les journaux, etc., en cliquant sur le nom du service spécifique (yogaposes dans notre cas).

Vous avez terminé le développement et le déploiement de notre application Web de recommandation de postures de yoga sur Cloud Run.

10. Félicitations

Félicitations ! Vous avez créé une application qui importe un ensemble de données dans Firestore, génère des représentations vectorielles continues et effectue une recherche de similarité vectorielle en fonction de la requête de l'utilisateur.

Documents de référence

• Firestore
• Firestore : recherche avec des embeddings vectoriels
• Gérer les index dans Firestore
• Cloud Run
• Langchain Document Loader pour Firestore
• Langchain Vector Store pour Firestore