1. Einführung
In diesem Codelab erfahren Sie, wie Sie die KI-Integration von Cloud SQL for PostgreSQL verwenden, indem Sie die Vektorsuche mit Vertex AI-Einbettungen kombinieren.
Voraussetzungen
- Grundlegende Kenntnisse von Google Cloud und der Console
- Grundlegende Kenntnisse der Befehlszeile und Cloud Shell
Aufgaben in diesem Lab
- Cloud SQL for PostgreSQL-Instanz bereitstellen
- Datenbank erstellen und Cloud SQL-KI-Integration aktivieren
- Daten in die Datenbank laden
- Vertex AI-Embedding-Modell in Cloud SQL verwenden
- Ergebnisse mit dem generativen Modell von Vertex AI ergänzen
- Leistung mithilfe eines Vektorindexes verbessern
Voraussetzungen
- Ein Google Cloud-Konto und ein Google Cloud-Projekt
- Ein Webbrowser wie Chrome, der die Google Cloud Console und Cloud Shell unterstützt
2. Einrichtung und Anforderungen
Einrichtung der Umgebung im eigenen Tempo
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie ein Konto erstellen.
- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es ist ein Zeichenstring, der von Google APIs nicht verwendet wird. Sie können ihn jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und kann nach der Festlegung nicht mehr geändert werden. In der Cloud Console wird automatisch ein eindeutiger String generiert. In der Regel spielt es keine Rolle, wie er lautet. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (normalerweise als
PROJECT_IDgekennzeichnet). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige generieren. Alternativ können Sie Ihr eigenes Konto ausprobieren und prüfen, ob es verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs ist kostenlos oder kostet nur sehr wenig. Wenn Sie die Ressourcen deaktivieren möchten, um Kosten nach Abschluss dieser Anleitung zu vermeiden, können Sie die von Ihnen erstellten Ressourcen oder das Projekt löschen. Neuen Google Cloud-Nutzern steht das kostenlose Testprogramm mit einem Guthaben von 300$ zur Verfügung.
Cloud Shell starten
Sie können Google Cloud zwar per Fernzugriff von Ihrem Laptop aus nutzen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Klicken Sie in der Google Cloud Console rechts oben in der Symbolleiste auf das Cloud Shell-Symbol:
Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Minuten dauern. Wenn der Vorgang abgeschlossen ist, sollte in etwa Folgendes angezeigt werden:
Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud. Dadurch werden Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.
3. Hinweis
API aktivieren
Ausgabe:
Prüfen Sie in Cloud Shell, ob Ihre Projekt-ID eingerichtet ist:
gcloud config set project [YOUR-PROJECT-ID]
Legen Sie die Umgebungsvariable PROJECT_ID fest:
PROJECT_ID=$(gcloud config get-value project)
Aktivieren Sie alle erforderlichen Dienste:
gcloud services enable sqladmin.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Erwartete Ausgabe
student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable sqladmin.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.
4. Cloud SQL-Instanz erstellen
Cloud SQL-Instanz mit Datenbankeinbindung in Vertex AI erstellen
Datenbankpasswort erstellen
Legen Sie ein Passwort für den Standarddatenbanknutzer fest. Sie können ein eigenes Passwort definieren oder eine Zufallsfunktion verwenden, um eins zu generieren:
export CLOUDSQL_PASSWORD=`openssl rand -hex 12`
Notieren Sie sich den generierten Wert für das Passwort:
echo $CLOUDSQL_PASSWORD
Cloud SQL for PostgreSQL-Instanz erstellen
Führen Sie in der Cloud Shell-Sitzung Folgendes aus:
gcloud sql instances create my-cloudsql-instance \
--database-version=POSTGRES_16 \
--tier=db-custom-1-3840 \
--region=us-central1 \
--edition=ENTERPRISE \
--enable-google-ml-integration \
--database-flags cloudsql.enable_google_ml_integration=on
Nachdem wir die Instanz erstellt haben, müssen wir ein Passwort für den Standardnutzer in der Instanz festlegen und prüfen, ob wir mit dem Passwort eine Verbindung herstellen können.
gcloud sql users set-password postgres \
--instance=my-cloudsql-instance \
--password=$CLOUDSQL_PASSWORD
Führen Sie den Befehl aus und geben Sie Ihr Passwort in die Aufforderung ein, wenn die Verbindung hergestellt werden kann.
gcloud sql connect my-cloudsql-instance --user=postgres
Vertex AI-Einbindung aktivieren
Gewähren Sie dem internen Cloud SQL-Dienstkonto die erforderlichen Berechtigungen, damit die Vertex AI-Integration verwendet werden kann.
Ermitteln Sie die E-Mail-Adresse des internen Cloud SQL-Dienstkontos und exportieren Sie sie als Variable.
SERVICE_ACCOUNT_EMAIL=$(gcloud sql instances describe my-cloudsql-instance --format="value(serviceAccountEmailAddress)")
echo $SERVICE_ACCOUNT_EMAIL
Gewähren Sie dem Cloud SQL-Dienstkonto Zugriff auf Vertex AI:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
--role="roles/aiplatform.user"
Weitere Informationen zum Erstellen und Konfigurieren von Instanzen finden Sie in der Cloud SQL-Dokumentation.
5. Datenbank vorbereiten
Jetzt müssen wir eine Datenbank erstellen und die Unterstützung von Vektoren aktivieren.
Datenbank erstellen
Erstellen Sie eine Datenbank mit dem Namen quickstart_db. Dazu stehen verschiedene Optionen zur Verfügung, z. B. Befehlszeilen-Datenbankclients wie psql für PostgreSQL, das SDK oder Cloud SQL Studio. Wir verwenden das SDK (gcloud), um Datenbanken zu erstellen und eine Verbindung zur Instanz herzustellen.
Führen Sie in Cloud Shell den Befehl zum Erstellen der Datenbank aus.
gcloud sql databases create quickstart_db --instance=my-cloudsql-instance
Erweiterungen aktivieren
Damit wir mit Vertex AI und Vektoren arbeiten können, müssen wir zwei Erweiterungen in unserer erstellten Datenbank aktivieren.
Führen Sie in Cloud Shell den Befehl aus, um eine Verbindung zur erstellten Datenbank herzustellen. Sie müssen Ihr Passwort angeben.
gcloud sql connect my-cloudsql-instance --database quickstart_db --user=postgres
Führen Sie nach der erfolgreichen Verbindung in der SQL-Sitzung zwei Befehle aus:
CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector CASCADE;
Beenden Sie die SQL-Sitzung:
exit;
6. Daten laden
Jetzt müssen wir Objekte in der Datenbank erstellen und Daten laden. Wir verwenden fiktive Daten des Cymbal-Shops. Die Daten sind im öffentlichen Google Storage-Bucket im CSV-Format verfügbar.
Zuerst müssen wir alle erforderlichen Objekte in unserer Datenbank erstellen. Dazu verwenden wir die bereits bekannten Befehle gcloud sql connect und gcloud storage, um die Schemaobjekte herunterzuladen und in unsere Datenbank zu importieren.
Führen Sie in der Cloud Shell den folgenden Befehl aus und geben Sie das Passwort ein, das Sie beim Erstellen der Instanz notiert haben:
gcloud storage cat gs://cloud-training/gcc/gcc-tech-004/cymbal_demo_schema.sql |gcloud sql connect my-cloudsql-instance --database quickstart_db --user=postgres
Was haben wir genau mit dem vorherigen Befehl getan? Wir haben eine Verbindung zu unserer Datenbank hergestellt und den heruntergeladenen SQL-Code ausgeführt, wodurch Tabellen, Indexe und Sequenzen erstellt wurden.
Im nächsten Schritt laden wir die Daten. Dazu müssen wir die CSV-Dateien aus Google Cloud Storage herunterladen.
gcloud storage cp gs://cloud-training/gcc/gcc-tech-004/cymbal_products.csv .
gcloud storage cp gs://cloud-training/gcc/gcc-tech-004/cymbal_inventory.csv .
gcloud storage cp gs://cloud-training/gcc/gcc-tech-004/cymbal_stores.csv .
Dann müssen wir eine Verbindung zur Datenbank herstellen.
gcloud sql connect my-cloudsql-instance --database quickstart_db --user=postgres
und Daten aus unseren CSV-Dateien importieren.
\copy cymbal_products from 'cymbal_products.csv' csv header
\copy cymbal_inventory from 'cymbal_inventory.csv' csv header
\copy cymbal_stores from 'cymbal_stores.csv' csv header
Beenden Sie die SQL-Sitzung:
exit;
Wenn Sie eigene Daten haben und Ihre CSV-Dateien mit dem Cloud SQL-Importtool kompatibel sind, das in der Cloud Console verfügbar ist, können Sie es anstelle der Befehlszeile verwenden.
7. Einbettungen erstellen
Im nächsten Schritt erstellen wir mit dem Modell „textembedding-004“ von Google Vertex AI Einbettungen für unsere Produktbeschreibungen und speichern sie als Vektordaten.
Stellen Sie eine Verbindung zur Datenbank her:
gcloud sql connect my-cloudsql-instance --database quickstart_db --user=postgres
Erstellen Sie dann mit der Funktion „Einbetten“ eine virtuelle Spalte embedding in der Tabelle „cymbal_products“.
ALTER TABLE cymbal_products ADD COLUMN embedding vector(768) GENERATED ALWAYS AS (embedding('text-embedding-004',product_description)) STORED;
Das kann einige Zeit in Anspruch nehmen, bei 900 bis 1.000 Zeilen sollte es jedoch nicht länger als 5 Minuten dauern. Normalerweise geht es viel schneller.
8. Ähnlichkeitssuche ausführen
Wir können jetzt eine Ähnlichkeitssuche mit den für die Beschreibungen berechneten Vektorwerten und dem Vektorwert ausführen, den wir für unsere Anfrage erhalten.
Die SQL-Abfrage kann über dieselbe Befehlszeilenschnittstelle mit gcloud sql connect oder alternativ über Cloud SQL Studio ausgeführt werden. Mehrzeilige und komplexe Abfragen lassen sich in Cloud SQL Studio besser verwalten.
Cloud SQL Studio starten
Klicken Sie in der Console auf die Cloud SQL-Instanz, die Sie zuvor erstellt haben.
Wenn er geöffnet ist, sehen wir im rechten Bereich Cloud SQL Studio. Wählen Sie diese Option aus.
Daraufhin wird ein Dialogfeld geöffnet, in dem Sie den Datenbanknamen und Ihre Anmeldedaten angeben:
- Datenbank: quickstart_db
- Nutzer: postgres
- Passwort: das von Ihnen notierte Passwort für den Hauptnutzer der Datenbank
Klicken Sie auf die Schaltfläche „AUTHENTIFIEREN“.
Das nächste Fenster wird geöffnet. Klicken Sie rechts auf den Tab „Editor“, um den SQL-Editor zu öffnen.
Jetzt können wir unsere Abfragen ausführen.
Abfrage ausführen
Führe eine Abfrage aus, um eine Liste der verfügbaren Produkte zu erhalten, die der Anfrage eines Kunden am ehesten entsprechen. Die Anfrage, die wir an Vertex AI senden, um den Vektorwert zu erhalten, lautet: „Welche Obstbäume gedeihen hier gut?“
Mit dieser Abfrage können Sie die ersten 10 Elemente auswählen, die für unsere Anfrage am besten geeignet sind:
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) as distance
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
distance ASC
LIMIT 10;
Kopieren Sie die Abfrage, fügen Sie sie in den Cloud SQL Studio-Editor ein und klicken Sie auf die Schaltfläche „AUSFÜHREN“ oder fügen Sie sie in die Befehlszeilen-Sitzung ein, die mit der Datenbank „quickstart_db“ verbunden ist.
Und hier ist eine Liste der ausgewählten Produkte, die der Suchanfrage entsprechen.
product_name | description | sale_price | zip_code | distance -------------------------+----------------------------------------------------------------------------------+------------+----------+--------------------- Cherry Tree | This is a beautiful cherry tree that will produce delicious cherries. It is an d | 75.00 | 93230 | 0.43922018972266397 Meyer Lemon Tree | Meyer Lemon trees are California's favorite lemon tree! Grow your own lemons by | 34 | 93230 | 0.4685112926118228 Toyon | This is a beautiful toyon tree that can grow to be over 20 feet tall. It is an e | 10.00 | 93230 | 0.4835677149651668 California Lilac | This is a beautiful lilac tree that can grow to be over 10 feet tall. It is an d | 5.00 | 93230 | 0.4947204525907498 California Peppertree | This is a beautiful peppertree that can grow to be over 30 feet tall. It is an e | 25.00 | 93230 | 0.5054166905547247 California Black Walnut | This is a beautiful walnut tree that can grow to be over 80 feet tall. It is a d | 100.00 | 93230 | 0.5084219510932597 California Sycamore | This is a beautiful sycamore tree that can grow to be over 100 feet tall. It is | 300.00 | 93230 | 0.5140519790508755 Coast Live Oak | This is a beautiful oak tree that can grow to be over 100 feet tall. It is an ev | 500.00 | 93230 | 0.5143126438081371 Fremont Cottonwood | This is a beautiful cottonwood tree that can grow to be over 100 feet tall. It i | 200.00 | 93230 | 0.5174774727252058 Madrone | This is a beautiful madrona tree that can grow to be over 80 feet tall. It is an | 50.00 | 93230 | 0.5227400803389093 (10 rows)
9. LLM-Antwort mit abgerufenen Daten verbessern
Wir können die Antwort des LLM für die generative KI für eine Clientanwendung mit dem Ergebnis der ausgeführten Abfrage verbessern und eine aussagekräftige Ausgabe mit den bereitgestellten Abfrageergebnissen als Teil des Prompts für ein generatives Basis-Sprachmodell von Vertex AI erstellen.
Dazu müssen wir ein JSON mit den Ergebnissen der Vektorsuche generieren und dieses dann als Ergänzung zu einem Prompt für ein LLM-Modell in Vertex AI verwenden, um eine aussagekräftige Ausgabe zu erstellen. Im ersten Schritt generieren wir die JSON-Datei, testen sie dann in Vertex AI Studio und fügen sie im letzten Schritt in eine SQL-Anweisung ein, die in einer Anwendung verwendet werden kann.
Ausgabe im JSON-Format generieren
Ändern Sie die Abfrage so, dass die Ausgabe im JSON-Format generiert wird und nur eine Zeile zurückgegeben wird, die an Vertex AI übergeben wird.
Cloud SQL for PostgreSQL
Hier ein Beispiel für die Abfrage:
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;
Und hier ist die erwartete JSON-Ausgabe:
[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]
Prompt in Vertex AI Studio ausführen
Wir können die generierte JSON-Datei als Teil des Prompts für das generative KI-Textmodell in Vertex AI Studio verwenden.
Öffnen Sie den Vertex AI Studio-Chat in der Cloud Console.
Möglicherweise werden Sie aufgefordert, zusätzliche APIs zu aktivieren. Sie können diese Aufforderung ignorieren. Für dieses Lab benötigen wir keine zusätzlichen APIs.
Hier ist der Prompt, den wir verwenden werden:
You are a friendly advisor helping to find a product based on the customer's needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}
Here is the list of products:
[place your JSON here]
The customer asked "What tree is growing the best here?"
You should give information about the product, price and some supplemental information.
Do not ask any additional questions and assume location based on the zip code provided in the list of products.
So sieht es aus, wenn wir den JSON-Platzhalter durch die Antwort aus der Abfrage ersetzen:
You are a friendly advisor helping to find a product based on the customer's needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","description":"some description","sale_price":10,"zip_code": 10234, "produt_id": "02056727942aeb714dc9a2313654e1b0"}
Here is the list of products:
[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]
The customer asked "What tree is growing the best here?"
You should give information about the product, price and some supplemental information.
Do not ask any additional questions and assume location based on the zip code provided in the list of products.
Und hier ist das Ergebnis, wenn wir den Prompt mit unseren JSON-Werten und dem gemini-2.0-Flash-Modell ausführen:
Im Folgenden sehen Sie die Antwort, die wir in diesem Beispiel vom Modell erhalten haben. Hinweis: Ihre Antwort kann aufgrund von Modell- und Parameteränderungen im Laufe der Zeit abweichen:
„Okay, laut der verfügbaren Produktliste ist der Kirschbaum der beste Baum, der in Ihrer Region gut wachsen könnte.
Der Preis beträgt 75,00 $.
Ich habe zwar keine genauen Informationen zu den Anbaubedingungen in Ihrer Postleitzahl (93230), aber Kirschbäume gedeihen im Allgemeinen in Gebieten mit gemäßigtem Klima und gut durchlässigem Boden. Sie benötigen in der Regel eine gewisse Zeit der Winterkälte, um Früchte zu tragen. Das sollten Sie berücksichtigen. Sie können jedoch eine wunderbare Ergänzung für einen Garten sein und bei den richtigen Bedingungen sowohl Schönheit als auch köstliche Kirschen bieten.“
Prompt in PSQL ausführen
Wir können auch die Cloud SQL-KI-Integration mit Vertex AI verwenden, um die ähnliche Antwort von einem generativen Modell mit SQL direkt in der Datenbank abzurufen. Damit wir das Modell „gemini-2.0-flash-exp“ verwenden können, müssen wir es zuerst registrieren.
In Cloud SQL for PostgreSQL ausführen
Führen Sie ein Upgrade der Erweiterung auf Version 1.4.2 oder höher durch, falls die aktuelle Version niedriger ist. Stellen Sie wie bereits gezeigt über gcloud sql connect eine Verbindung zur Datenbank „quickstart_db“ her (oder verwenden Sie Cloud SQL Studio) und führen Sie Folgendes aus:
SELECT extversion from pg_extension where extname='google_ml_integration';
Wenn der zurückgegebene Wert unter 1.4.2 liegt, führe Folgendes aus:
ALTER EXTENSION google_ml_integration UPDATE TO '1.4.2';
Als Nächstes müssen wir das Datenbank-Flag „google_ml_integration.enable_model_support“ auf „on“ setzen. Dazu können Sie die Webkonsole oder den folgenden gcloud-Befehl verwenden.
gcloud sql instances patch my-cloudsql-instance \
--database-flags google_ml_integration.enable_model_support=on,cloudsql.enable_google_ml_integration=on
Die Ausführung des Befehls im Hintergrund dauert etwa 1 bis 3 Minuten. Anschließend können Sie das neue Flag in der psql-Sitzung oder mit Cloud SQL Studio prüfen, indem Sie eine Verbindung zur Datenbank „quickstart_db“ herstellen.
show google_ml_integration.enable_model_support;
Die erwartete Ausgabe der psql-Sitzung ist „on“:
quickstart_db => show google_ml_integration.enable_model_support; google_ml_integration.enable_model_support -------------------------------------------- on (1 row)
Dann müssen wir zwei Modelle registrieren. Das erste ist das bereits verwendete Modell text-embedding-004. Es muss registriert werden, da wir die Modellregistrierungsfunktionen aktiviert haben.
Führen Sie in psql oder Cloud SQL Studio den folgenden Code aus, um das Modell zu registrieren:
CALL
google_ml.create_model(
model_id => 'text-embedding-004',
model_provider => 'google',
model_qualified_name => 'text-embedding-004',
model_type => 'text_embedding',
model_auth_type => 'cloudsql_service_agent_iam',
model_in_transform_fn => 'google_ml.vertexai_text_embedding_input_transform',
model_out_transform_fn => 'google_ml.vertexai_text_embedding_output_transform');
Das nächste Modell, das wir registrieren müssen, ist gemini-2.0-flash-001. Es wird verwendet, um die nutzerfreundliche Ausgabe zu generieren.
CALL
google_ml.create_model(
model_id => 'gemini-2.0-flash-001',
model_request_url => 'https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-2.0-flash-001:streamGenerateContent',
model_provider => 'google',
model_auth_type => 'cloudsql_service_agent_iam');
Sie können die Liste der registrierten Modelle jederzeit überprüfen, indem Sie Informationen aus der google_ml.model_info_view auswählen.
select model_id,model_type from google_ml.model_info_view;
Hier eine Beispielausgabe
quickstart_db=> select model_id,model_type from google_ml.model_info_view;
model_id | model_type
--------------------------------------+----------------
textembedding-gecko | text_embedding
textembedding-gecko@001 | text_embedding
gemini-1.5-pro:streamGenerateContent | generic
gemini-1.5-pro:generateContent | generic
gemini-1.0-pro:generateContent | generic
text-embedding-004 | text_embedding
gemini-2.0-flash-001 | generic
Jetzt können wir das in einer untergeordneten Abfrage generierte JSON als Teil des Prompts für das generative KI-Textmodell mit SQL bereitstellen.
Führen Sie die Abfrage in der psql- oder Cloud SQL Studio-Sitzung für die Datenbank aus.
WITH trees AS (
SELECT
cp.product_name,
cp.product_description AS description,
cp.sale_price,
cs.zip_code,
cp.uniq_id AS product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci ON
ci.uniq_id = cp.uniq_id
JOIN cymbal_stores cs ON
cs.store_id = ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> google_ml.embedding('text-embedding-004',
'What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1),
prompt AS (
SELECT
'You are a friendly advisor helping to find a product based on the customer''s needs.
Based on the client request we have loaded a list of products closely related to search.
The list in JSON format with list of values like {"product_name":"name","product_description":"some description","sale_price":10}
Here is the list of products:' || json_agg(trees) || 'The customer asked "What kind of fruit trees grow well here?"
You should give information about the product, price and some supplemental information' AS prompt_text
FROM
trees),
response AS (
SELECT
json_array_elements(google_ml.predict_row( model_id =>'gemini-2.0-flash-001',
request_body => json_build_object('contents',
json_build_object('role',
'user',
'parts',
json_build_object('text',
prompt_text)))))->'candidates'->0->'content'->'parts'->0->'text' AS resp
FROM
prompt)
SELECT
string_agg(resp::text,
' ')
FROM
response;
Und hier ist die erwartete Ausgabe. Die Ausgabe kann je nach Modellversion und Parametern variieren:
"That" "'s a great question! Based on your location (assuming you're" " in zip code 93230), I have a suggestion for a" " fruit tree that should thrive.\n\nWe have the **Cherry Tree** available.\n\n**Product Name:** Cherry Tree\n\n**Description:** This is a beautiful cherry" " tree that will produce delicious cherries. It's a deciduous tree (meaning it loses its leaves in the fall) growing to about 15 feet tall." " The leaves are dark green in summer, turning a beautiful red in the fall. Cherry trees are known for their beauty, shade, and privacy.\n\n**Sale Price:** $75.00\n\n**Important Considerations for Growing" " Cherry Trees:**\n\n* **Climate:** Cherry trees prefer a cool, moist climate, and 93230 falls within a suitable range (USDA zones 4-9). However, it's always a good idea to" " check the specific microclimate of your property (sun exposure, drainage etc.).\n* **Soil:** They do best in sandy soil. If your soil is different, you may need to amend it to improve drainage.\n* **Pollination:** Many cherry varieties require a second, compatible cherry tree for proper pollination" ". Check the specific pollination needs of this variety before purchase if you want a significant cherry yield.\n\nThis cherry tree is a beautiful addition to any yard and will provide you with delicious cherries if you can meet its needs. Would you like to know more about its pollination requirements, or perhaps see if we have any other" " fruit trees suitable for your area?\n" ""
10. Index für den nächsten Nachbarn erstellen
Unser Datenbestand ist recht klein und die Antwortzeit hängt hauptsächlich von den Interaktionen mit KI-Modellen ab. Bei Millionen von Vektoren kann die Vektorsuche jedoch einen erheblichen Teil unserer Antwortzeit in Anspruch nehmen und das System stark belasten. Um das zu verbessern, können wir einen Index auf unseren Vektoren erstellen.
HNSW-Index erstellen
Wir werden den HNSW-Indextyp für unseren Test verwenden. HNSW steht für Hierarchical Navigable Small World (hierarchisch navigierbare kleine Welt) und ist ein mehrschichtiger Graphindex.
Um den Index für die Einbettungsspalte zu erstellen, müssen wir die Einbettungsspalte, die Entfernungsfunktion und optional Parameter wie „m“ oder „ef_constructions“ definieren. Weitere Informationen zu den Parametern finden Sie in der Dokumentation.
CREATE INDEX cymbal_products_embeddings_hnsw ON cymbal_products
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
Erwartete Ausgabe:
quickstart_db=> CREATE INDEX cymbal_products_embeddings_hnsw ON cymbal_products USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64); CREATE INDEX quickstart_db=>
Antwort vergleichen
Jetzt können wir die Vektorsuchabfrage im Modus EXPLAIN ausführen und prüfen, ob der Index verwendet wurde.
EXPLAIN (analyze)
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;
Erwartete Ausgabe:
Aggregate (cost=779.12..779.13 rows=1 width=32) (actual time=1.066..1.069 rows=1 loops=1)
-> Subquery Scan on trees (cost=769.05..779.12 rows=1 width=142) (actual time=1.038..1.041 rows=1 loops=1)
-> Limit (cost=769.05..779.11 rows=1 width=158) (actual time=1.022..1.024 rows=1 loops=1)
-> Nested Loop (cost=769.05..9339.69 rows=852 width=158) (actual time=1.020..1.021 rows=1 loops=1)
-> Nested Loop (cost=768.77..9316.48 rows=852 width=945) (actual time=0.858..0.859 rows=1 loops=1)
-> Index Scan using cymbal_products_embeddings_hnsw on cymbal_products cp (cost=768.34..2572.47 rows=941 width=941) (actual time=0.532..0.539 rows=3 loops=1)
Order By: (embedding <=> '[0.008864171,0.03693164,-0.024245683,...
<redacted>
...,0.017593635,-0.040275685,-0.03914233,-0.018452475,0.00826032,-0.07372604
]'::vector)
-> Index Scan using product_inventory_pkey on cymbal_inventory ci (cost=0.42..7.17 rows=1 width=37) (actual time=0.104..0.104 rows=0 loops=3)
Index Cond: ((store_id = 1583) AND (uniq_id = (cp.uniq_id)::text))
Filter: (inventory > 0)
Rows Removed by Filter: 1
-> Materialize (cost=0.28..8.31 rows=1 width=8) (actual time=0.133..0.134 rows=1 loops=1)
-> Index Scan using product_stores_pkey on cymbal_stores cs (cost=0.28..8.30 rows=1 width=8) (actual time=0.129..0.129 rows=1 loops=1)
Index Cond: (store_id = 1583)
Planning Time: 112.398 ms
Execution Time: 1.221 ms
Aus der Ausgabe geht hervor, dass für die Abfrage „Index Scan using cymbal_products_embeddings_hnsw“ verwendet wurde.
Wenn wir die Abfrage ohne „explain“ ausführen, erhalten wir Folgendes:
WITH trees as (
SELECT
cp.product_name,
left(cp.product_description,80) as description,
cp.sale_price,
cs.zip_code,
cp.uniq_id as product_id
FROM
cymbal_products cp
JOIN cymbal_inventory ci on
ci.uniq_id=cp.uniq_id
JOIN cymbal_stores cs on
cs.store_id=ci.store_id
AND ci.inventory>0
AND cs.store_id = 1583
ORDER BY
(cp.embedding <=> embedding('text-embedding-004','What kind of fruit trees grow well here?')::vector) ASC
LIMIT 1)
SELECT json_agg(trees) FROM trees;
Erwartete Ausgabe:
[{"product_name":"Cherry Tree","description":"This is a beautiful cherry tree that will produce delicious cherries. It is an d","sale_price":75.00,"zip_code":93230,"product_id":"d536e9e823296a2eba198e52dd23e712"}]
Das Ergebnis ist dasselbe und es wird derselbe Kirschbaum zurückgegeben, der bei der Suche ohne Index an erster Stelle stand. Je nach Parametern und Indextyp kann das Ergebnis leicht abweichen. Bei meinen Tests wurden mit der indexierten Abfrage Ergebnisse in 131.301 ms im Vergleich zu 167.631 ms ohne Index zurückgegeben. Es handelte sich jedoch um einen sehr kleinen Datensatz. Bei größeren Datensätzen wäre der Unterschied wesentlich größer.
In der Dokumentation finden Sie verschiedene für die Vektoren verfügbare Indizes sowie weitere Labs und Beispiele mit LangChain-Integration.
11. Umgebung bereinigen
Cloud SQL-Instanz löschen
Cloud SQL-Instanz nach Abschluss des Labs löschen
Definieren Sie in Cloud Shell die Projekt- und Umgebungsvariablen, wenn die Verbindung getrennt wurde und alle vorherigen Einstellungen verloren gegangen sind:
export INSTANCE_NAME=my-cloudsql-instance
export PROJECT_ID=$(gcloud config get-value project)
Löschen Sie die Instanz:
gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID
Erwartete Console-Ausgabe:
student@cloudshell:~$ gcloud sql instances delete $INSTANCE_NAME --project=$PROJECT_ID All of the instance data will be lost when the instance is deleted. Do you want to continue (Y/n)? y Deleting Cloud SQL instance...done. Deleted [https://sandbox.googleapis.com/v1beta4/projects/test-project-001-402417/instances/my-cloudsql-instance].
12. Glückwunsch
Herzlichen Glückwunsch zum Abschluss des Codelabs.
Behandelte Themen
- Cloud SQL for PostgreSQL-Instanz bereitstellen
- Datenbank erstellen und Cloud SQL-KI-Integration aktivieren
- Daten in die Datenbank laden
- Vertex AI-Embedding-Modell in Cloud SQL verwenden
- Ergebnisse mit dem generativen Modell von Vertex AI ergänzen
- Leistung mithilfe eines Vektorindexes verbessern
Ähnliches Codelab für AlloyDB mit ScaNN-Index anstelle von HNSW ausprobieren
13. Umfrage
Ausgabe: