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.

In diesem Codelab gehen Sie schrittweise so vor:

1. Verwenden Sie ein vorhandenes Hugging Face-Dataset mit Yoga-Posen (JSON-Format).
2. Erweitern Sie den Datensatz mit einer zusätzlichen Feldbeschreibung, in der Gemini Beschreibungen für die einzelnen Posen generiert.
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 zusammenführt, wie unten dargestellt:

Aufgaben

• Entwerfen, entwickeln und stellen Sie eine Webanwendung bereit, die Vektorsuche verwendet, um Yoga-Posen zu empfehlen.

Lerninhalte

• Wie Sie mit Gemini Textinhalte generieren, und im Kontext dieses Codelabs Beschreibungen für Yoga-Posen
• Langchain Document Loader für Firestore verwenden, um Datensätze aus einem erweiterten Dataset von Hugging Face zusammen mit Vektoreinbettungen in Firestore zu laden
• Langchain Vector Store for Firestore verwenden, um Daten auf Grundlage einer Anfrage in natürlicher Sprache zu suchen
• Audioinhalte mit der Google Cloud Text-to-Speech API generieren

Voraussetzungen

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

In diesem Codelab, das sich an Entwickler*innen aller Erfahrungsstufen (auch Anfänger*innen) richtet, wird Python in der Beispielanwendung verwendet. 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 zur 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 in der bq vorinstalliert ist. Klicken Sie oben in der Google Cloud Console auf „Cloud Shell aktivieren“.

4. Sobald die Verbindung mit der Cloud Shell hergestellt ist, können Sie mit dem folgenden Befehl prüfen, ob Sie bereits authentifiziert sind und für das Projekt schon Ihre Projekt-ID eingestellt ist:

gcloud auth list

5. Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass 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 unten gezeigten Befehl. Das 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

Bei erfolgreicher Ausführung des Befehls sollte eine Meldung wie die unten gezeigte angezeigt werden:

Operation "operations/..." finished successfully.

Alternativ zum gcloud-Befehl können Sie in der Konsole nach den einzelnen Produkten suchen oder diesen Link verwenden.

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

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

Repository klonen und Umgebungseinstellungen einrichten

Als Nächstes klonen Sie das Beispiel-Repository, auf das wir im Rest des Codelabs verweisen. Wenn Sie sich in Cloud Shell befinden, geben Sie den folgenden Befehl in Ihrem Basisverzeichnis 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, wie unten dargestellt:

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

Wir müssen jetzt 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"

Aktualisieren Sie die Werte für project_id und location entsprechend den Angaben, die Sie beim Erstellen des Google Cloud-Projekts und der Firestore-Datenbankregion ausgewählt haben. Im Idealfall 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 entsprechend Ihrer Konfiguration festlegen müssen).

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

Der letzte Schritt besteht nun darin, eine Python-Umgebung zu erstellen, die wir lokal verwenden werden, wobei alle Python-Abhängigkeiten für uns eingerichtet werden. Sehen Sie sich die Datei pyproject.toml an, die die Details dazu enthält. Der Inhalt ist unten zu sehen:

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 bereits in requirements.txt. versionsgesperrt. Zusammenfassend lässt sich sagen, dass wir eine virtuelle Python-Umgebung mit den Python-Paketabhängigkeiten in requirements.txt erstellen müssen, die in der virtuellen Umgebung installiert werden sollen. Rufen Sie dazu in der Cloud Shell IDE Command Palette (Strg+Umschalt+P) auf und geben Sie Python: Create Environment ein. Führen Sie die nächsten Schritte aus, um eine Virtual Environment(venv)-, Python 3.x interpreter- und requirements.txt-Datei 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:

Super! 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 default-Datenbank, indem Sie auf Create Database klicken. Verwenden Sie beim Erstellen der Datenbank die folgenden Werte:

• Firestore-Modus: Native.
• Wählen Sie als Standorttyp Region und als Standort für die Region us-central1 aus.
• Verwenden Sie für die Sicherheitsregeln Test rules.
• Erstellen Sie die Datenbank.

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

Wenn Sie Firebase verwenden, ist das dieselbe Firestore, die Sie bereits kennen. Tatsächlich können Sie über die Firebase Console auf dieselbe Datenbankinstanz zugreifen.

Damit ist der Abschnitt zum Einrichten der Firestore-Datenbank abgeschlossen.

4. Yoga-Posen-Dataset vorbereiten

Als Erstes müssen wir das Dataset „Yoga Poses“ vorbereiten, das wir für die Anwendung verwenden werden. Wir beginnen mit einem vorhandenen Hugging Face-Dataset und erweitern es dann mit zusätzlichen Informationen.

Hugging Face-Dataset für Yoga-Posen In diesem Codelab wird zwar eines der Datasets verwendet, Sie können aber auch ein beliebiges anderes Dataset verwenden und die gleichen Techniken anwenden, um das Dataset zu optimieren.

Wenn wir zum Bereich Files and versions gehen, können wir die JSON-Datendatei für alle Posen abrufen.

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

Wir demonstrieren den gesamten Prozess der Generierung von Beschreibungen und schließlich der Generierung der Einbettungen anhand einer kleineren Teilmenge von einigen Datensätzen, damit Sie mit dem Prozess vertraut sind.

Rufen Sie die Datei data/yoga_poses.json im Cloud Shell Editor auf und sehen Sie sich die Liste der JSON-Objekte an. Jedes JSON-Objekt stellt eine Yoga-Pose dar. Wir haben insgesamt drei Datensätze. Ein Beispieldatensatz ist unten zu sehen:

{
   "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 das Standardmodell selbst verwenden können, um ein description-Feld dafür zu generieren.

Rufen Sie im Cloud Shell-Editor die Datei generate-descriptions.py auf. Der Inhalt dieser Datei wird unten angezeigt:

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-Datensatz für Yogaposen ein neues Feld description hinzugefügt. Die Beschreibung wird durch einen Aufruf des Gemini-Modells abgerufen, dem wir den erforderlichen Prompt zur Verfügung stellen. 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 (d.h. für jede Yoga-Beitragsinformation) Folgendes aus:
3. Dabei werden pose_name, sanskrit_name, expertise_level und pose_types extrahiert.
4. Dazu wird die Funktion „generate_description“ aufgerufen, die einen Prompt erstellt und dann die Langchain VertexAI-Modellklasse aufruft, um den Antworttext abzurufen.
5. Dieser Antworttext wird dann dem JSON-Objekt hinzugefügt.
6. Die aktualisierte JSON-Liste von Objekten 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 zur Autorisierung aufgefordert werden, geben Sie die erforderlichen Informationen an.

Die Anwendung wird ausgeführt. Wir haben eine Verzögerung von 30 Sekunden zwischen den Datensätzen eingefügt, um Ratenbegrenzungskontingente zu vermeiden, die möglicherweise für neue Google Cloud-Konten gelten. Bitte haben Sie etwas Geduld.

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

Sobald alle drei Datensätze mit dem Gemini-Aufruf optimiert wurden, wird die Datei data/yoga_poses_with_description.json generiert. Das können Sie sich ansehen.

Wir haben jetzt unsere Datendatei. Im nächsten Schritt geht es darum, wie wir eine Firestore-Datenbank damit füllen und Embeddings generieren.

5. Daten in Firestore importieren und Vektoreinbettungen generieren

Wir haben die Datei data/yoga_poses_with_description.json und müssen jetzt die Firestore-Datenbank damit füllen und vor allem die Vektoreinbettungen für jeden Datensatz generieren. Die Vektoreinbettungen sind später nützlich, wenn wir eine Ähnlichkeitssuche mit der in natürlicher Sprache angegebenen Nutzeranfrage durchführen müssen.

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

So gehen Sie vor:

1. Wir konvertieren die Liste der JSON-Objekte in eine Liste von Langchain Document-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 String, der aus der Verkettung einiger Felder besteht.
2. Sobald wir eine Liste von Document-Objekten haben, verwenden wir die Langchain-Klasse FirestoreVectorStore und insbesondere die Methode from_documents 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 auch ein embedding-Feld generiert.

Der Code für import-data.py ist unten angegeben (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, sehen Sie eine Meldung ähnlich der folgenden:

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

Wenn Sie prüfen möchten, ob die Datensätze erfolgreich eingefügt und die Einbettungen generiert wurden, rufen Sie in der Cloud Console die Firestore-Seite auf.

Klicken Sie auf die Standarddatenbank. Daraufhin sollten die Sammlung test-poses und mehrere Dokumente unter dieser Sammlung angezeigt werden. Jedes Dokument entspricht einer Yoga-Pose.

Klicken Sie auf eines der Dokumente, um die Felder zu untersuchen. Zusätzlich zu den Feldern, die wir importiert haben, finden Sie auch das Feld embedding. Dies ist ein Vektorfeld, das automatisch für Sie über die von uns verwendete Langchain-Klasse VertexAIEmbeddings generiert wurde, in der wir das Vertex AI-Einbettungsmodell text-embedding-004 angegeben haben.

Nachdem die Datensätze mit den Einbettungen in die Firestore-Datenbank hochgeladen wurden, können wir mit dem nächsten Schritt fortfahren und sehen, wie eine Vektorähnlichkeitssuche in Firestore durchgeführt wird.

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

Wir erstellen jetzt die Sammlung poses, die eine vollständige Liste mit 160 Yoga-Posen enthält. Für diese haben wir eine Datenbankimportdatei generiert, die Sie direkt importieren können. Das soll Zeit im Lab sparen. Der Prozess zum Generieren der Datenbank mit der Beschreibung und den Einbettungen ist derselbe wie im vorherigen Abschnitt.

So importieren Sie die Datenbank:

1. Erstellen Sie mit dem unten angegebenen Befehl gsutil 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 nun die zu importierenden Daten haben, können wir mit dem letzten Schritt fortfahren: dem Import der Daten in die von uns erstellte Firebase-Datenbank (default).

3. Verwenden Sie den unten angegebenen gcloud-Befehl:

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

Der Import dauert einige Sekunden. Danach können Sie Ihre Firestore-Datenbank und die Sammlung unter https://console.cloud.google.com/firestore/databases validieren. Wählen Sie dazu die Datenbank default und die Sammlung poses aus, wie unten dargestellt:

Damit ist die Firestore-Sammlung, die wir in unserer Anwendung verwenden, erstellt.

7. Suche nach Vektorähnlichkeiten in Firestore durchführen

Für die Suche nach Vektorähnlichkeiten wird die Anfrage des Nutzers verwendet. 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 Nutzeranfrage verwendet werden soll. 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 diesen Code mit einigen Beispielanfragen ausführen, müssen Sie zuerst einen zusammengesetzten Firestore-Index generieren, der für erfolgreiche Suchanfragen erforderlich ist. Wenn Sie die Anwendung ausführen, ohne den Index zu erstellen, wird eine Fehlermeldung angezeigt, die darauf hinweist, dass Sie den Index zuerst erstellen müssen. Außerdem wird der Befehl zum Erstellen des Index angezeigt.

Der gcloud-Befehl zum Erstellen des zusammengesetzten Index ist unten dargestellt:

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 Erstellung des Index dauert einige Minuten, da die Datenbank mehr als 150 Einträge enthält. Anschließend können Sie den Index mit dem unten gezeigten 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. Ein Beispiel für einen Lauf sehen Sie unten:

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

Wenn das funktioniert, haben wir verstanden, wie wir die Firestore-Vektordatenbank verwenden, um Datensätze hochzuladen, Einbettungen zu generieren und eine Vektorähnlichkeitssuche durchzuführen. Wir können jetzt eine Webanwendung erstellen, in die die Vektorsuche in ein Web-Frontend eingebunden wird.

8. Die Webanwendung

Die Python Flask-Webanwendung ist in der Datei main.py und die HTML-Datei für das Frontend in der Datei templates/index.html. verfügbar.

Wir empfehlen, sich beide Dateien anzusehen. Beginnen Sie mit der Datei main.py, die den Handler /search enthält. Dieser übernimmt den Prompt, der von der Frontend-HTML-Datei index.html übergeben wurde. Dadurch wird die Suchmethode aufgerufen, die die Vektorähnlichkeitssuche durchführt, die wir uns im vorherigen Abschnitt angesehen haben.

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

Anwendung lokal ausführen

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

python main.py

Unten sehen Sie ein Beispiel für die Ausführung:

 * 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

Sobald die Anwendung ausgeführt wird, können Sie die Start-URL der Anwendung aufrufen, indem Sie auf die unten gezeigte Schaltfläche „Webvorschau“ klicken:

Die index.html-Datei sollte wie unten dargestellt angezeigt werden:

Geben Sie eine Beispielanfrage an (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, über die ein Audio-Stream auf Grundlage der Beschreibung generiert wird, den Sie sich 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 Deployment-Befehl wird unten angezeigt. Achten Sie darauf, dass Sie vor dem Deployment die Werte für die Variable (<<YOUR_PROJECT_ID>>) durch die Werte ersetzen, die für Ihr Projekt spezifisch sind. 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 oben genannten Befehl im Stammordner der Anwendung aus. Möglicherweise werden Sie auch aufgefordert, Google Cloud APIs zu aktivieren und verschiedene Berechtigungen zu bestätigen.

Das Deployment dauert etwa 5 bis 7 Minuten.

Nach erfolgreicher Bereitstellung wird in der Bereitstellungsausgabe die Cloud Run-Dienst-URL angegeben. Sie hat das folgende Format:

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

Wenn Sie diese öffentliche URL aufrufen, sollten Sie dieselbe Webanwendung sehen, die bereitgestellt wurde und erfolgreich ausgeführt wird.

Sie können auch in der Google Cloud Console Cloud Run aufrufen. Dort wird die Liste der Dienste in Cloud Run angezeigt. Der Dienst yogaposes sollte einer der (oder der einzige) dort aufgeführten Dienste sein.

Sie können die Details des Dienstes wie URL, Konfigurationen und Logs aufrufen, indem Sie auf den jeweiligen Dienstnamen klicken (in unserem Fall yogaposes).

Damit ist die Entwicklung und Bereitstellung unserer Webanwendung zur Empfehlung von Yoga-Posen in Cloud Run abgeschlossen.

10. Glückwunsch

Sie haben eine Anwendung erstellt, die ein Dataset in Firestore hochlädt, die Einbettungen generiert und eine Suche nach Vektorähnlichkeit basierend auf der Nutzeranfrage durchführt.

Referenzdokumente

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