Codelab – Eine kontextbezogene Empfehlungs-App für Yoga-Posen mit Firestore, Vector Search, LangChain und Gemini erstellen (Python-Version)

1. Einführung

In diesem Codelab erstellen Sie eine Anwendung, die mithilfe der Vektorsuche Yoga-Posen empfiehlt.

Im Codelab gehen Sie so vor:

1. Verwenden Sie einen vorhandenen Hugging Face-Datensatz mit Yoga-Posen (JSON-Format).
2. Ergänzen Sie den Datensatz um eine zusätzliche Feldbeschreibung, mit der mit Gemini Beschreibungen für jede der Posen generiert werden.
3. Verwenden Sie LangChain, um ein Dokument zu erstellen, und die Firestore LangChain-Integration, um die Sammlung und die Einbettungen in Firestore zu erstellen.
4. Erstellen Sie einen zusammengesetzten Index in Firestore, um die Vektorsuche zu ermöglichen.
5. Verwenden Sie die Vektorsuche in einer Flask-Anwendung, die alles wie unten gezeigt zusammenführt:

Aufgabe

• Eine Webanwendung entwerfen, erstellen und bereitstellen, die Yoga-Posen anhand der Vektorsuche empfiehlt.

Aufgaben in diesem Lab

• Mit Gemini Textinhalte generieren und im Rahmen dieses Codelabs Beschreibungen für Yoga-Posen generieren
• Mit dem LangChain Document Loader für Firestore Datensätze aus einem erweiterten Hugging Face-Dataset zusammen mit Vektor-Embeddings in Firestore laden
• Mit dem LangChain-Vektorspeicher für Firestore nach Daten anhand einer Abfrage in natürlicher Sprache suchen
• Audioinhalte mit der Google Cloud Text-to-Speech API generieren

Voraussetzungen

• Chrome-Webbrowser
• Ein Gmail-Konto
• Ein Cloud-Projekt mit aktivierter Abrechnung

Dieses Codelab richtet sich an Entwickler aller Stufen (einschließlich Anfänger) und verwendet in der Beispielanwendung Python. Python-Kenntnisse sind jedoch nicht erforderlich, um die vorgestellten Konzepte zu verstehen.

2. Hinweis

Projekt erstellen

1. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
2. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
3. Sie verwenden Cloud Shell, eine Befehlszeilenumgebung, die in Google Cloud ausgeführt wird und bq bereits vorinstalliert hat. Klicken Sie oben in der Google Cloud Console auf „Cloud Shell aktivieren“.

4. Nachdem Sie eine Verbindung zu Cloud Shell hergestellt haben, prüfen Sie mit dem folgenden Befehl, ob Sie bereits authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:

gcloud auth list

5. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt.

gcloud config list project

6. Wenn Ihr Projekt nicht festgelegt ist, verwenden Sie den folgenden Befehl, um es festzulegen:

gcloud config set project <YOUR_PROJECT_ID>

7. Aktivieren Sie die erforderlichen APIs mit dem folgenden Befehl. Dies kann einige Minuten dauern.

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

Wenn der Befehl erfolgreich ausgeführt wurde, sollte eine Meldung ähnlich der folgenden angezeigt werden:

Operation "operations/..." finished successfully.

Alternativ können Sie in der Console nach den einzelnen Produkten suchen oder diesen Link verwenden.

Wenn eine API fehlt, können Sie sie jederzeit während der Implementierung aktivieren.

Weitere Informationen zu gcloud-Befehlen und deren Verwendung finden Sie in der Dokumentation.

Repository klonen und Umgebungseinstellungen einrichten

Im nächsten Schritt klonen wir das Beispiel-Repository, auf das wir im Rest des Codelabs verweisen werden. Angenommen, Sie befinden sich in Cloud Shell, geben Sie in Ihrem Basisverzeichnis den folgenden Befehl ein:

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

Klicken Sie zum Starten des Editors in der Symbolleiste des Cloud Shell-Fensters auf „Editor öffnen“. Klicken Sie links oben auf die Menüleiste und wählen Sie „Datei“ > „Ordner öffnen“ aus (siehe Abbildung unten).

Wählen Sie den Ordner yoga-poses-recommender-python aus. Der Ordner sollte sich mit den folgenden Dateien öffnen:

Jetzt müssen wir die Umgebungsvariablen einrichten, die wir verwenden werden. Klicken Sie auf die Datei config.template.yaml. Der Inhalt sollte wie unten dargestellt aussehen:

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"

Bitte aktualisieren Sie die Werte für project_id und location gemäß den Angaben, die Sie beim Erstellen des Google Cloud-Projekts und der Firestore-Datenbankregion ausgewählt haben. Idealerweise sollten die Werte von location für das Google Cloud-Projekt und die Firestore-Datenbank gleich sein, z.B. us-central1.

Für dieses Codelab verwenden wir die vorkonfigurierten Werte, mit Ausnahme von project_id und location, die Sie gemäß Ihrer Konfiguration festlegen müssen.

Speichern Sie diese Datei als config.yaml im selben Ordner wie die Datei config.template.yaml.

Im letzten Schritt erstellen wir eine Python-Umgebung, die wir lokal mit allen für uns eingerichteten Python-Abhängigkeiten verwenden. Sehen Sie sich die Datei pyproject.toml an, die die Details dazu enthält. Der Inhalt ist unten dargestellt:

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

Diese Abhängigkeiten sind in requirements.txt bereits versionsgemäß gesperrt.. Zusammenfassend müssen wir eine virtuelle Python-Umgebung mit den Python-Paketabhängigkeiten in requirements.txt erstellen, die in der virtuellen Umgebung installiert werden sollen. Klicken Sie dazu in der Cloud Shell IDE auf Command Palette (Strg + Umschalttaste + P) und geben Sie Python: Create Environment ein. Führen Sie die nächsten Schritte aus, um eine Virtual Environment(venv), eine Python 3.x interpreter und die Datei requirements.txt auszuwählen.

Nachdem die Umgebung erstellt wurde, müssen wir sie mit dem folgenden Befehl aktivieren:

source .venv/bin/activate

In der Konsole sollte (.venv) angezeigt werden. Beispiel: -> (.venv) yourusername@cloudshell:

Sehr gut! Jetzt können wir mit der Einrichtung der Firestore-Datenbank fortfahren.

3. Firestore einrichten

Cloud Firestore ist eine vollständig verwaltete serverlose Dokumentendatenbank, die wir als Backend für unsere Anwendungsdaten verwenden. Daten in Cloud Firestore sind in Sammlungen von Dokumenten strukturiert.

Firestore-Datenbank initialisieren

Rufen Sie in der Cloud Console die Seite „Firestore“ auf.

Wenn Sie noch keine Firestore-Datenbank im Projekt initialisiert haben, erstellen Sie die Datenbank default, indem Sie auf Create Database klicken. Verwenden Sie beim Erstellen der Datenbank die folgenden Werte:

• Firestore-Modus: Native.
• Standort: Verwenden Sie die Standardeinstellungen für die Standortermittlung.
• Verwenden Sie für die Sicherheitsregeln Test rules.
• Erstellen Sie die Datenbank.

Im nächsten Abschnitt legen wir die Grundlage für die Erstellung einer Sammlung mit dem Namen poses in unserer Standard-Firestore-Datenbank. Diese Sammlung enthält Beispieldaten (Dokumente) oder Informationen zu Yoga-Posen, die wir dann in unserer Anwendung verwenden.

Hinweis: Es handelt sich dabei um den Firestore, den Sie bereits von Firebase kennen. Sie können dieselbe Datenbankinstanz auch über die Firebase Console aufrufen.

Damit ist der Abschnitt zur Einrichtung der Firestore-Datenbank abgeschlossen.

4. Yoga-Pose-Dataset vorbereiten

Als Erstes müssen wir das Dataset mit Yoga-Posen vorbereiten, das wir für die Anwendung verwenden werden. Wir beginnen mit einem vorhandenen Hugging Face-Datensatz und ergänzen ihn dann um zusätzliche Informationen.

Sehen Sie sich den Hugging Face-Dataset für Yoga-Posen an. In diesem Codelab wird zwar einer der Datasets verwendet, Sie können aber auch ein beliebiges anderes Dataset verwenden und dieselben Techniken anwenden, um es zu optimieren.

Im Bereich Files and versions können wir die JSON-Datendatei für alle Posen abrufen.

Wir haben die Datei yoga_poses.json heruntergeladen und Ihnen zur Verfügung gestellt. Diese Datei heißt yoga_poses_alldata.json und befindet sich im Ordner /data.

Wir zeigen Ihnen den gesamten Prozess zum Erstellen von Beschreibungen und schließlich zum Erstellen der Einbettungen anhand einer kleineren Teilmenge von wenigen Einträgen, damit Sie mit dem Verfahren vertraut sind.

Rufen Sie im Cloud Shell-Editor die Datei data/yoga_poses.json auf und sehen Sie sich die Liste der JSON-Objekte an. Jedes JSON-Objekt steht für eine Yoga-Pose. Es gibt insgesamt drei Einträge. Unten sehen Sie ein Beispiel:

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

Das ist eine gute Gelegenheit, Gemini vorzustellen und zu zeigen, wie wir mit dem Standardmodell ein description-Feld generieren können.

Rufen Sie im Cloud Shell-Editor die Datei generate-descriptions.py auf. Der Inhalt dieser Datei ist unten zu sehen:

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

Mit dieser Anwendung wird jedem JSON-Eintrag für Yoga-Posen ein neues Feld description hinzugefügt. Die Beschreibung wird über einen Aufruf des Gemini-Modells abgerufen, in dem wir den erforderlichen Prompt bereitstellen. Das Feld wird der JSON-Datei hinzugefügt und die neue Datei wird in die Datei data/yoga_poses_with_descriptions.json geschrieben.

Sehen wir uns die wichtigsten Schritte an:

1. In der Funktion main() wird die Funktion add_descriptions_to_json aufgerufen und die erwartete Eingabe- und Ausgabedatei angegeben.
2. Die Funktion add_descriptions_to_json führt für jeden JSON-Datensatz, also für die Informationen zum Yoga-Beitrag, Folgendes aus:
3. Es werden pose_name, sanskrit_name, expertise_level und pose_types extrahiert.
4. Dabei wird die Funktion „generate_description“ aufgerufen, die einen Prompt erstellt, und dann die Modellklasse Langchain VertexAI, um den Antworttext abzurufen.
5. Dieser Antworttext wird dann dem JSON-Objekt hinzugefügt.
6. Die aktualisierte JSON-Liste der Objekte wird dann in die Zieldatei geschrieben.

Führen wir diese Anwendung aus. Öffnen Sie ein neues Terminalfenster (Strg + Umschalt + C) und geben Sie den folgenden Befehl ein:

python generate-descriptions.py

Wenn Sie um eine Autorisierung gebeten werden, stellen Sie diese bitte zur Verfügung.

Die Anwendung wird ausgeführt. Wir haben eine Verzögerung von 30 Sekunden zwischen den Einträgen hinzugefügt, um Ratenlimitquoten zu vermeiden, die bei neuen Google Cloud-Konten auftreten können. Bitte haben Sie etwas Geduld.

Unten sehen Sie ein Beispiel für einen laufenden Test:

Sobald alle drei Einträge mit dem Gemini-Aufruf erweitert wurden, wird die Datei data/yoga_poses_with_description.json generiert. Sie können sich das ansehen.

Wir haben jetzt unsere Datendatei. Im nächsten Schritt erfahren Sie, wie Sie damit eine Firestore-Datenbank füllen und Einbettungen generieren.

5. Daten in Firestore importieren und Vektoreinbettungen generieren

Wir haben die Datei data/yoga_poses_with_description.json und müssen sie jetzt in die Firestore-Datenbank einfügen und vor allem die Vektor-Embeddings für jeden der Einträge generieren. Die Vektor-Embeddings sind später nützlich, wenn wir eine Ähnlichkeitssuche mit der Nutzerabfrage in natürlicher Sprache durchführen müssen.

Wir verwenden die Langchain Firestore-Komponenten, um den oben beschriebenen Prozess zu implementieren.

Gehen Sie dazu so vor:

1. Wir konvertieren die Liste der JSON-Objekte in eine Liste von Langchain-Dokument-Objekten. Jedes Dokument hat zwei Attribute: page_content und metadata. Das Metadatenobjekt enthält das gesamte JSON-Objekt mit Attributen wie name, description und sanskrit_name. page_content ist ein Stringtext, der aus mehreren Feldern zusammengesetzt ist.
2. Sobald wir eine Liste von Document-Objekten haben, verwenden wir die FirestoreVectorStore-Langchain-Klasse und insbesondere die from_documents-Methode mit dieser Liste von Dokumenten, einem Sammlungsnamen (wir verwenden die Variable TEST_COLLECTION, die auf test-poses verweist), einer Vertex AI-Embedding-Klasse und den Firestore-Verbindungsdetails (PROJECT_ID und DATABASE-Name). Dadurch wird die Sammlung erstellt und für jedes Attribut wird ein embedding-Feld generiert.

Der Code für import-data.py ist unten zu sehen (Teile des Codes wurden aus Gründen der Übersichtlichkeit gekürzt):

... 

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

Führen wir diese Anwendung aus. Öffnen Sie ein neues Terminalfenster (Strg + Umschalt + C) und geben Sie den folgenden Befehl ein:

python import-data.py

Wenn alles wie geplant ausgeführt wird, sollte eine Meldung wie die folgende angezeigt werden:

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

Ob die Einträge erfolgreich eingefügt und die Einbettungen generiert wurden, können Sie in der Cloud Console auf der Firestore-Seite prüfen.

Klicken Sie auf die (Standard-)Datenbank. Daraufhin sollten die Sammlung test-poses und mehrere Dokumente in dieser Sammlung angezeigt werden. Jedes Dokument ist eine Yoga-Pose.

Klicken Sie auf eines der Dokumente, um die Felder zu untersuchen. Zusätzlich zu den importierten Feldern finden Sie das Feld embedding. Es handelt sich dabei um ein Vektorfeld, das automatisch für Sie über die von uns verwendete LangChain-Klasse VertexAIEmbeddings generiert wurde, in der wir das Vertex AI-Embedding-Modell text-embedding-004 angegeben haben.

Nachdem wir die Einträge mit den Einbettungen in die Firestore-Datenbank hochgeladen haben, können wir mit dem nächsten Schritt fortfahren und uns ansehen, wie eine Vektorähnlichkeitssuche in Firestore funktioniert.

6. Vollständige Yoga-Posen in die Firestore-Datenbanksammlung importieren

Wir erstellen jetzt die Sammlung poses, eine vollständige Liste von 160 Yoga-Posen. Dazu haben wir eine Datenbankimportdatei generiert, die Sie direkt importieren können. So sparen Sie Zeit im Lab. Das Erstellen der Datenbank mit Beschreibung und Einbettungen erfolgt wie im vorherigen Abschnitt beschrieben.

So importieren Sie die Datenbank:

1. Erstellen Sie mit dem Befehl gsutil unten einen Bucket in Ihrem Projekt. Ersetzen Sie die Variable <PROJECT_ID> im folgenden Befehl durch Ihre Google Cloud-Projekt-ID.

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

2. Nachdem der Bucket erstellt wurde, müssen wir den vorbereiteten Datenbankexport in diesen Bucket kopieren, bevor wir ihn in die Firebase-Datenbank importieren können. Verwenden Sie den folgenden Befehl:

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

Nachdem wir die Daten zum Importieren haben, können wir mit dem letzten Schritt fortfahren, bei dem die Daten in die von uns erstellte Firebase-Datenbank (default) importiert werden.

3. Verwenden Sie den folgenden gcloud-Befehl:

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

Der Import dauert einige Sekunden. Sobald er abgeschlossen ist, können Sie Ihre Firestore-Datenbank und die Sammlung validieren. Rufen Sie dazu https://console.cloud.google.com/firestore/databases auf und wählen Sie die Datenbank default und die Sammlung poses aus (siehe Abbildung unten):

Damit ist die Erstellung der Firestore-Sammlung abgeschlossen, die wir in unserer Anwendung verwenden werden.

7. Vektorähnlichkeitssuche in Firestore ausführen

Für die Suche nach Vektorähnlichkeiten nehmen wir die Suchanfrage des Nutzers auf. Ein Beispiel für diese Abfrage ist "Suggest me some exercises to relieve back pain".

Sehen Sie sich die Datei search-data.py an. Die wichtigste Funktion ist die Suchfunktion, die unten dargestellt ist. Im Wesentlichen wird eine Einbettungsklasse erstellt, die zum Generieren der Einbettung für die Nutzerabfrage verwendet wird. Anschließend wird die Klasse FirestoreVectorStore verwendet, um die Funktion similarity_search aufzurufen.

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)

Bevor Sie dies mit einigen Abfragebeispielen ausführen, müssen Sie zuerst einen Firestore-zusammengesetzten Index generieren, der für erfolgreiche Suchanfragen erforderlich ist. Wenn Sie die Anwendung ausführen, ohne den Index zu erstellen, wird ein Fehler angezeigt, der darauf hinweist, dass Sie den Index zuerst erstellen müssen.

Unten sehen Sie den Befehl gcloud zum Erstellen des zusammengesetzten Index:

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

Die Indexierung dauert einige Minuten, da sich mehr als 150 Einträge in der Datenbank befinden. Sobald der Vorgang abgeschlossen ist, können Sie den Index mit dem folgenden Befehl aufrufen:

gcloud firestore indexes composite list

Der gerade erstellte Index sollte in der Liste angezeigt werden.

Probieren Sie jetzt den folgenden Befehl aus:

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

Sie sollten einige Empfehlungen erhalten. Unten sehen Sie ein Beispiel für einen Testlauf:

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

Sobald das funktioniert, wissen Sie, wie Sie mit der Firestore-Vektordatenbank Datensätze hochladen, Einbettungen generieren und eine Vektorähnlichkeitssuche durchführen. Wir können jetzt eine Webanwendung erstellen, in der die Vektorsuche in ein Web-Frontend eingebunden wird.

8. Die Webanwendung

Die Python Flask-Webanwendung ist in der Datei main.py verfügbar und die Front-End-HTML-Datei befindet sich in templates/index.html..

Wir empfehlen, sich beide Dateien anzusehen. Beginnen Sie mit der Datei main.py, die den Handler /search enthält, der den Prompt übernimmt, der von der Front-End-HTML-Datei index.html übergeben wurde. Dadurch wird die Suchmethode aufgerufen, die die im vorherigen Abschnitt beschriebene Suche nach Vektorähnlichkeit durchführt.

Die Antwort wird dann mit der Liste der Empfehlungen an die index.html zurückgesendet. Über das Symbol index.html werden die Empfehlungen dann als verschiedene Karten angezeigt.

Anwendung lokal ausführen

Öffnen Sie ein neues Terminalfenster (Strg + Umschalt + C) oder ein vorhandenes Terminalfenster und geben Sie den folgenden Befehl ein:

python main.py

Eine Beispielausführung ist unten dargestellt:

 * 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

Wenn die Anwendung einsatzbereit ist, rufen Sie die Start-URL der Anwendung auf, indem Sie auf die Schaltfläche „Webvorschau“ unten klicken:

Es sollte die index.html-Datei angezeigt werden, die wie unten dargestellt bereitgestellt wird:

Geben Sie eine Beispielabfrage ein (z. B. Provide me some exercises for back pain relief) und klicken Sie auf die Schaltfläche Search. Dadurch sollten einige Empfehlungen aus der Datenbank abgerufen werden. Außerdem wird die Schaltfläche Play Audio angezeigt. Wenn Sie darauf klicken, wird anhand der Beschreibung ein Audiostream generiert, den Sie direkt anhören können.

9. Optional: In Google Cloud Run bereitstellen

Im letzten Schritt stellen wir diese Anwendung in Google Cloud Run bereit. Der Befehl zum Bereitstellen wird unten angezeigt. Ersetzen Sie vor dem Bereitstellen die Werte für die Variable (<<YOUR_PROJECT_ID>>) durch die für Ihr Projekt spezifischen Werte. Diese Werte können Sie aus der Datei config.yaml abrufen.

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

Führen Sie den Befehl oben im Stammverzeichnis der Anwendung aus. Möglicherweise werden Sie auch aufgefordert, Google Cloud APIs zu aktivieren und Ihre Einwilligung für verschiedene Berechtigungen zu erteilen. Bitte tun Sie dies.

Die Bereitstellung dauert etwa 5 bis 7 Minuten. Bitte haben Sie etwas Geduld.

Nach der erfolgreichen Bereitstellung wird in der Bereitstellungsausgabe die URL des Cloud Run-Dienstes angezeigt. Sie hat folgendes Format:

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

Wenn Sie diese öffentliche URL aufrufen, sollte dieselbe Webanwendung bereitgestellt und erfolgreich ausgeführt werden.

Sie können auch Cloud Run in der Google Cloud Console aufrufen. Dort sehen Sie eine Liste der Cloud Run-Dienste. Der Dienst yogaposes sollte einer der dort aufgeführten Dienste sein (falls nicht der einzige).

Sie können Details zum Dienst wie URL, Konfigurationen und Protokolle aufrufen, indem Sie auf den jeweiligen Dienstnamen klicken (in unserem Fall yogaposes).

Damit ist die Entwicklung und Bereitstellung unserer Webanwendung für Yoga-Pose-Empfehlungen in Cloud Run abgeschlossen.

10. Glückwunsch

Herzlichen Glückwunsch! Sie haben eine Anwendung erstellt, die einen Datensatz in Firestore hochlädt, die Einbettungen generiert und eine Vektorähnlichkeitssuche basierend auf der Nutzerabfrage durchführt.

Referenzdokumente

• Firestore
• Firestore – Mit Vektoreinbettungen suchen
• Indexe in Firestore verwalten
• Cloud Run
• Langchain Document Loader für Firestore
• Langchain Vector Store für Firestore