Korzystanie z modelu Jev od TypeSafe AI z funkcjami AI AlloyDB do szybkiego wykonywania zapytań AI

1. Wprowadzenie

W tym ćwiczeniu połączysz model Jev firmy TypeSafe AI z AlloyDB AI, korzystając z natywnych funkcji AI AlloyDB (ai.if, ai.analyze_sentiment i ml_predict_row). Dzięki temu możesz przeprowadzać wydajne wnioskowanie zbiorcze za pomocą modelu Jev bezpośrednio na danych operacyjnych w AlloyDB, bez konieczności przenoszenia danych ani pisania złożonego kodu po stronie aplikacji.

Jakie zadania wykonasz

  • Udostępnianie dostępu do usług prywatnych (PSA) oraz klastra i instancji głównej AlloyDB for PostgreSQL
  • Tworzenie reguły zapory sieciowej VPC zezwalającej na połączenia z Cloud Shell i połączenia wewnętrzne
  • wczytać przykładowy zbiór danych e-commerce za pomocą gcloud alloydb clusters import,
  • Włączanie rozszerzenia google_ml_integration usługi Google Secret Manager i AlloyDB
  • Przechowywanie klucza interfejsu API TypeSafe AI i przyznawanie do niego dostępu w usłudze Secret Manager
  • Utwórz funkcje przekształcania danych wejściowych i wyjściowych PL/pgSQL dla typów podstawowych Jev noul (wartość logiczna) i choice (nastawienie)
  • Rejestrowanie niestandardowego punktu końcowego modelu jev-model w AlloyDB
  • Uruchamianie skalarnych i grupowanych w tablice zapytań semantycznych (ai.if i ai.analyze_sentiment) bezpośrednio w SQL
  • Wykonywanie zapytań dotyczących rzeczywistych opinii klientów o produktach w celu klasyfikacji nastrojów za pomocą ai.analyze_sentiment
  • (Bonus) Zarejestruj ogólny punkt końcowy (jev-systemone) i oceń ciągłą intensywność zadowolenia klienta za pomocą elementu podstawowego score Jeva.

Czego potrzebujesz

  • przeglądarkę internetową, np. Chrome;
  • projekt Google Cloud z włączonymi rozliczeniami,
  • klucz interfejsu API TypeSafe AI (z TypeSafe AI).

2. Zanim zaczniesz

Wybór projektu Google Cloud

W konsoli Google Cloud wybierz lub utwórz projekt w chmurze Google Cloud, którego chcesz użyć.

Uruchamianie Cloud Shell

W prawym górnym rogu konsoli Google Cloud kliknij Aktywuj Cloud Shell.

Sprawdź, czy sesja Cloud Shell jest uwierzytelniona:

gcloud auth list

Ustaw identyfikator projektu i zmienne środowiskowe:

export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project $PROJECT_ID

export REGION="us-west4"
export ADBCLUSTER="my-alloydb-cluster"
export ADBINSTANCE="my-alloydb-primary"

Włączanie wymaganych interfejsów Google Cloud API

Uruchom to polecenie, aby włączyć wszystkie niezbędne interfejsy API usług Google Cloud:

gcloud services enable \
  alloydb.googleapis.com \
  servicenetworking.googleapis.com \
  secretmanager.googleapis.com \
  compute.googleapis.com

3. Udostępnianie klastra AlloyDB i instancji głównej

W tym kroku przydzielisz zakres adresów IP prywatnego dostępu do usług w sieci VPC, ustanowisz prywatne połączenie równorzędne i udostępnisz klaster AlloyDB oraz instancję podstawową z wychodzącym dostępem do internetu.

1. Tworzenie zakresu adresów IP prywatnego dostępu do usług (PSA)

AlloyDB wymaga przydzielenia zakresu prywatnych adresów IP w sieci prywatnego środowiska wirtualnego w chmurze (VPC). Zakładając, że używasz sieci VPC default:

Utwórz przydział zakresu prywatnych adresów IP:

gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default

Nawiąż prywatne połączenie równorzędne VPC:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default

2. Tworzenie klastra AlloyDB

Wygeneruj bezpieczne hasło do bazy danych dla początkowego użytkownika z dostępem administracyjnym postgres:

export PGPASSWORD="$(openssl rand -hex 8)@1aA"
echo "Your generated AlloyDB postgres password is: $PGPASSWORD"

Utwórz klaster bezpłatnej wersji próbnej AlloyDB:

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION 

3. Tworzenie instancji głównej z flagami AI i połączeniami wychodzącymi

AlloyDB łączy się bezpośrednio z bezpiecznym punktem końcowym SaaS TypeSafe AI (https://api.typesafe.ai/v1/systemone) przez wychodzące połączenie HTTPS. Dlatego musisz podać --outbound-public-ip. Dodatkowo skonfiguruj flagi bazy danych AlloyDB AI dla środowiska:

gcloud alloydb instances create $ADBINSTANCE \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --cluster=$ADBCLUSTER \
    --outbound-public-ip \
    --ssl-mode=ALLOW_UNENCRYPTED_AND_ENCRYPTED \
    --database-flags=\
google_ml_integration.enable_model_support=on,\
google_ml_integration.enable_ai_query_engine=on,\
google_ml_integration.enable_ai_function_acceleration=on,\
google_ml_integration.enable_cost_optimized_ai_functions=on,\
parameterized_views.enabled=on,\
password.enforce_complexity=on,\
password.min_uppercase_letters=1,\
password.min_numerical_chars=1,\
password.min_pass_length=10

4. Wczytywanie przykładowych danych transakcji e-commerce

Aby przetestować realistyczne zapytania semantyczne, zaimportuj przykładowy zbiór danych e-commerce zawierający katalogi produktów i opinie klientów bezpośrednio z Cloud Storage:

gcloud alloydb clusters import $ADBCLUSTER \
    --region=$REGION \
    --project=$PROJECT_ID \
    --gcs-uri="gs://sample-data-and-media/ecomm-retail/ecom_generic.sql" \
    --sql \
    --database=postgres \
    --user=postgres

4. Przechowywanie klucza interfejsu API TypeSafe AI w usłudze Secret Manager

Zarządzanie punktami końcowymi modelu AlloyDB jest natywnie zintegrowane z usługą Google Secret Manager, co umożliwia uwierzytelnianie wywołań interfejsów API bez ujawniania danych logowania w postaci zwykłego tekstu w kodzie bazy danych lub logach konfiguracji.

1. Tworzenie obiektu tajnego

W Cloud Shell utwórz nowy obiekt tajny o nazwie typesafe-jev-api-key:

gcloud secrets create typesafe-jev-api-key \
  --replication-policy="automatic"

Dodaj klucz interfejsu TypeSafe AI API jako wersję obiektu tajnego:

echo -n "<YOUR_TYPESAFE_API_KEY>" | \
  gcloud secrets versions add typesafe-jev-api-key --data-file=-

2. Przyznawanie dostępu agentowi usługi AlloyDB

AlloyDB używa agenta usługi projektu do pobierania obiektów tajnych podczas wykonywania zapytania. Znajdź numer projektu i przyznaj rolę uzyskującego dostęp do obiektu tajnego:

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
ALLOYDB_SA="service-${PROJECT_NUMBER}@gcp-sa-alloydb.iam.gserviceaccount.com"

gcloud secrets add-iam-policy-binding typesafe-jev-api-key \
  --member="serviceAccount:${ALLOYDB_SA}" \
  --role="roles/secretmanager.secretAccessor"

Powinny wyświetlić się dane wyjściowe potwierdzające, że agent usługi otrzymał rolę roles/secretmanager.secretAccessor.

5. Łączenie się z AlloyDB za pomocą AlloyDB Studio i inicjowanie rozszerzeń bazy danych

Aby korzystać z bazy danych AlloyDB bezpośrednio w przeglądarce bez konfigurowania lokalnych narzędzi klienta ani tuneli proxy, użyj AlloyDB Studio w konsoli Google Cloud.

1. Otwieranie AlloyDB Studio

  1. W konsoli Google Cloud otwórz AlloyDB for PostgreSQL > Klastry.
  2. Kliknij klaster (my-alloydb-cluster).
  3. W menu nawigacyjnym po lewej stronie kliknij AlloyDB Studio.
  4. Uwierzytelnij się w bazie danych:
    • Baza danych: postgres
    • Użytkownik: postgres
    • Hasło: wpisz $PGPASSWORD wygenerowane podczas tworzenia klastra (np. uruchom echo $PGPASSWORD w Cloud Shell, aby je wyświetlić).
  5. Kliknij Uwierzytelnij.

Znajdujesz się teraz w interaktywnym edytorze zapytań SQL w AlloyDB Studio.

2. Włączanie rozszerzeń i flag bazy danych

W edytorze zapytań AlloyDB Studio wklej i uruchom te instrukcje, aby włączyć rozszerzenie google_ml_integration i skonfigurować ustawienia środowiska wykonawczego:

-- Enable the AlloyDB AI integration extension
CREATE EXTENSION IF NOT EXISTS google_ml_integration;

-- Enable preview AI functions (ai.analyze_sentiment, ai.classify)
SET google_ml_integration.enable_preview_ai_functions = 'on';

-- Disable async batching for the session to use custom transform functions directly
SET google_ml_integration.enable_async_operation = 'off';

Kliknij Uruchom, aby wykonać zapytanie.

3. Rejestrowanie obiektu tajnego w AlloyDB MEM

Wskaż AlloyDB, gdzie znaleźć klucz interfejsu API TypeSafe AI:

CALL google_ml.create_sm_secret(
    secret_id => 'jev_api_key',
    secret_path => 'projects/<YOUR_PROJECT_ID>/secrets/typesafe-jev-api-key/versions/latest'
);

6. Tworzenie funkcji przekształcenia SQL

Interfejs System One API firmy TypeSafe AI akceptuje uporządkowany kod JSON z odrębnymi elementami podstawowymi rozumowania (noul w przypadku ograniczeń logicznych, choice w przypadku klasyfikacji wieloklasowej).

Funkcja zarządzania punktami końcowymi modelu w AlloyDB używa 4 funkcji przekształcania (wejście skalarne, wyjście skalarne, wejście zbiorcze, wyjście zbiorcze), aby połączyć standardowe sygnatury funkcji ai.* PostgreSQL z formatem interfejsu Jev REST API.

1. Przekształcenie danych wejściowych skalarnych

Dodaj tę funkcję, aby przekształcić jednowierszowe wywołania ai.if i ai.analyze_sentiment w ładunki żądań Jev:

CREATE OR REPLACE FUNCTION public.jev_model_input_transform(
    model_id VARCHAR(100),
    input_text TEXT,
    generation_config JSON,
    system_instruction TEXT
) RETURNS JSON
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    full_instruction TEXT;
    enum_json JSON;
    criteria_obj JSONB := '{}'::JSONB;
    elem TEXT;
    q_obj JSON;
BEGIN
    -- Combine optional system instructions with the input prompt
    IF system_instruction IS NOT NULL AND length(trim(system_instruction)) > 0 THEN
        full_instruction := system_instruction || E'\n\n' || input_text;
    ELSE
        full_instruction := input_text;
    END IF;

    -- Inspect generation_config to determine whether caller expects a multi-class choice or boolean
    enum_json := COALESCE(
        generation_config->'generationConfig'->'responseSchema'->'enum',
        generation_config->'responseSchema'->'enum'
    );

    IF enum_json IS NOT NULL AND json_typeof(enum_json) = 'array' THEN
        -- Multi-class classification (ai.analyze_sentiment) -> Jev choice primitive
        FOR elem IN SELECT json_array_elements_text(enum_json) LOOP
            criteria_obj := criteria_obj || jsonb_build_object(elem, 'Category: ' || elem);
        END LOOP;
        q_obj := json_build_object(
            'type', 'choice',
            'instructions', full_instruction,
            'criteria', criteria_obj::JSON
        );
    ELSE
        -- Boolean filtering (ai.if) -> Jev noul primitive
        q_obj := json_build_object(
            'type', 'noul',
            'instructions', full_instruction
        );
    END IF;

    RETURN json_build_object(
        'model', 'jev-latest',
        'state', COALESCE(generation_config->>'state', 'Evaluate the question accurately based on the provided text.'),
        'questions', json_build_object('q_1', q_obj)
    );
END;
$$;

2. Przekształcenie danych wyjściowych skalara

Dodaj funkcję, która rozpakuje odpowiedź JSON Jeva z powrotem do wyniku TEXT PostgreSQL:

CREATE OR REPLACE FUNCTION public.jev_model_output_transform(
    model_id VARCHAR(100),
    response_json JSON
) RETURNS TEXT
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    q_ans JSON := response_json->'answers'->'q_1';
    ans_type TEXT := q_ans->>'type';
BEGIN
    IF ans_type = 'choice' THEN
        RETURN q_ans->>'choice';
    ELSIF ans_type = 'noul' THEN
        -- Convert probability score (0.00 to 1.00) to boolean text
        RETURN CASE WHEN (q_ans->>'noul')::FLOAT >= 0.50 THEN 'true' ELSE 'false' END;
    ELSE
        RAISE EXCEPTION 'Unexpected Jev response payload: %', response_json::TEXT;
    END IF;
END;
$$;

3. Przekształcenie danych wejściowych zbioru

Jev może oceniać dziesiątki pytań jednocześnie w ramach jednego cyklu HTTP bez pogorszenia jakości generowanych odpowiedzi.

Dodaj przekształcenie danych wejściowych zbioru, aby przekonwertować tablice prompts TEXT[] PostgreSQL na równoległe pytania Jev q_1 .. q_N:

CREATE OR REPLACE FUNCTION public.jev_model_batch_input_transform(
    model_id VARCHAR(100),
    prompts TEXT[],
    generation_config JSON,
    system_instructions JSON
) RETURNS JSON
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    questions_obj JSONB := '{}'::JSONB;
    enum_json JSON;
    criteria_obj JSONB := '{}'::JSONB;
    elem TEXT;
    is_choice BOOLEAN := FALSE;
    i INT;
BEGIN
    enum_json := COALESCE(
        generation_config->'generationConfig'->'responseSchema'->'items'->'enum',
        generation_config->'generationConfig'->'responseSchema'->'enum',
        generation_config->'responseSchema'->'items'->'enum',
        generation_config->'responseSchema'->'enum'
    );

    IF enum_json IS NOT NULL AND json_typeof(enum_json) = 'array' THEN
        IF NOT (enum_json::JSONB = '["true", "false"]'::JSONB OR enum_json::JSONB = '["false", "true"]'::JSONB) THEN
            is_choice := TRUE;
            FOR elem IN SELECT json_array_elements_text(enum_json) LOOP
                criteria_obj := criteria_obj || jsonb_build_object(elem, 'Category: ' || elem);
            END LOOP;
        END IF;
    END IF;

    -- Construct parallel questions for every prompt in the array
    FOR i IN 1 .. COALESCE(array_length(prompts, 1), 0) LOOP
        IF is_choice THEN
            questions_obj := questions_obj || jsonb_build_object(
                'q_' || i::TEXT,
                jsonb_build_object(
                    'type', 'choice',
                    'instructions', prompts[i],
                    'criteria', criteria_obj
                )
            );
        ELSE
            questions_obj := questions_obj || jsonb_build_object(
                'q_' || i::TEXT,
                jsonb_build_object(
                    'type', 'noul',
                    'instructions', prompts[i]
                )
            );
        END IF;
    END LOOP;

    RETURN json_build_object(
        'model', 'jev-latest',
        'state', COALESCE(generation_config->>'state', 'Evaluate each question independently based on the record data.'),
        'questions', questions_obj::JSON
    );
END;
$$;

4. Przekształcenie danych wyjściowych zbioru

Dodaj funkcję wyodrębniania odpowiedzi w odpowiedniej kolejności indeksu tablicy 1..N:

CREATE OR REPLACE FUNCTION public.jev_model_batch_output_transform(
    model_id VARCHAR(100),
    response JSON
) RETURNS TEXT[]
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    results TEXT[] := ARRAY[]::TEXT[];
    answers JSON := response->'answers';
    i INT := 1;
    q_ans JSON;
    ans_type TEXT;
BEGIN
    LOOP
        q_ans := answers->('q_' || i::TEXT);
        EXIT WHEN q_ans IS NULL;
        ans_type := q_ans->>'type';
        IF ans_type = 'choice' THEN
            results := array_append(results, q_ans->>'choice');
        ELSE
            results := array_append(results, CASE WHEN (q_ans->>'noul')::FLOAT >= 0.50 THEN 'true' ELSE 'false' END);
        END IF;
        i := i + 1;
    END LOOP;
    RETURN results;
END;
$$;

7. Rejestrowanie punktu końcowego modelu niestandardowego w AlloyDB

Teraz powiążesz funkcje przekształcania, tajne dane uwierzytelniające i punkt końcowy TypeSafe AI REST w zarejestrowany model o nazwie jev-model.

1. Zarejestruj jev-model

W edytorze zapytań AlloyDB Studio wklej i uruchom:

-- Drop previous registration if updating
DO $$
BEGIN
    IF EXISTS (SELECT 1 FROM google_ml.model_info_view WHERE model_id = 'jev-model') THEN
        CALL google_ml.drop_model('jev-model');
    END IF;
END $$;

-- Register custom LLM endpoint
CALL google_ml.create_model(
    model_id => 'jev-model',
    model_request_url => 'https://api.typesafe.ai/v1/systemone',
    model_provider => 'custom',
    model_type => 'llm',
    model_qualified_name => 'jev-latest',
    model_auth_type => 'secret_manager',
    model_auth_id => 'jev_api_key',
    model_in_transform_fn => 'jev_model_input_transform',
    model_out_transform_fn => 'jev_model_output_transform',
    model_batch_in_transform_fn => 'jev_model_batch_input_transform',
    model_batch_out_transform_fn => 'jev_model_batch_output_transform'
);

2. Zweryfikuj rejestrację

Wyślij zapytanie do widoku Model Registry, aby sprawdzić, czy model jev-model jest aktywny i rozpoznawany:

SELECT model_id, model_type, model_provider, model_auth_type 
FROM google_ml.model_info_view 
WHERE model_id = 'jev-model';

Dane wyjściowe powinny być podobne do tych:

 model_id | model_type | model_provider | model_auth_type 
----------+------------+----------------+-----------------
 jev-model  | llm        | custom         | secret_manager
(1 row)

8. Uruchamianie zapytań testowych w Jev

Po zarejestrowaniu jev-model możesz wykonywać operacje semantyczne bezpośrednio w standardowych zapytaniach PostgreSQL.

1. Testowanie filtrowania skalarnego wartości logicznych (ai.if)

Oceń pojedyncze stwierdzenie tekstowe za pomocą ai.if:

SELECT ai.if(
    prompt => 'Is the product "North Face Waterproof Gore-Tex Hiking Jacket ($249)" suitable for rainy outdoor conditions?',
    model_id => 'jev-model'
) AS is_suitable;

Dane wyjściowe powinny być podobne do tych:

 is_suitable 
-------------
 true
(1 row)

2. Analiza nastawienia w skali (ai.analyze_sentiment)

Oceń opinię klienta i przypisz jej etykietę kategorialną (positive, negative lub neutral):

SET google_ml_integration.enable_preview_ai_functions = 'on';
SELECT ai.analyze_sentiment(
    input => 'The stitching on this jacket tore on the second day and the zipper jammed completely.',
    model_id => 'jev-model'
) AS sentiment;

Dane wyjściowe powinny być podobne do tych:

 sentiment 
-----------
 negative
(1 row)

3. Testowanie filtrowania wartości logicznych w grupach tablic

Oceniaj wiele elementów w jednym zapytaniu, przekazując tablicę promptów:

SET google_ml_integration.enable_async_operation = 'off';
SELECT unnest(prompts) AS product_prompt,
       unnest(ai.if(prompts => prompts, model_id => 'jev-model')) AS is_cold_weather
FROM (
    SELECT ARRAY[
        'Is "Arctic Expedition Down Parka (-30F)" cold-weather winter outerwear?',
        'Is "Men''s Boardshorts Beach Swim Trunk" cold-weather winter outerwear?',
        'Is "Merino Wool Thermal Base Layer" cold-weather winter outerwear?'
    ] AS prompts
) b;

Dane wyjściowe powinny być podobne do tych:

                             product_prompt                              | is_cold_weather 
-------------------------------------------------------------------------+-----------------
 Is "Arctic Expedition Down Parka (-30F)" cold-weather winter outerwear? | true
 Is "Men's Boardshorts Beach Swim Trunk" cold-weather winter outerwear?  | false
 Is "Merino Wool Thermal Base Layer" cold-weather winter outerwear?      | false
(3 rows)

4. Testowanie zapytań do tabeli z grupowaniem tablic

Teraz prześlij zapytanie do tabeli ecomm.products wczytanej wcześniej podczas udostępniania klastra, używając ai.if na zbiorze elementów, aby sprawdzić, które produkty w katalogu są przeznaczone na zimę.

Aby przeprowadzić filtrowanie semantyczne o wysokiej przepustowości na danych tabeli (np. 50 wierszy na partię), użyj funkcji okna row_number() PostgreSQL, aby podzielić wiersze na partie:

-- Evaluate a 50-row batch of real catalog items from ecomm.products
WITH numbered AS (
    SELECT 
        id, 
        name, 
        category,
        product_description,
        ((row_number() OVER (ORDER BY id) - 1) / 50) AS batch_id
    FROM ecomm.products
    ORDER BY id DESC
    LIMIT 50
),
batched AS (
    SELECT 
        batch_id,
        array_agg(id ORDER BY id) AS ids,
        array_agg(name ORDER BY id) AS names,
        array_agg(category ORDER BY id) AS categories,
        array_agg(product_description ORDER BY id) AS descs,
        ai.if(
            prompts => array_agg('Is "' || name || '" designed for cold weather winter outerwear?' ORDER BY id),
            model_id => 'jev-model'
        ) AS decisions
    FROM numbered
    GROUP BY batch_id
),
unrolled AS (
    SELECT 
        b.batch_id,
        u.id,
        u.name,
        u.category,
        u.product_description,
        u.decision AS cold_weather_gear
    FROM batched b
    CROSS JOIN LATERAL unnest(b.ids, b.names, b.categories, b.descs, b.decisions) 
      AS u(id, name, category, product_description, decision)
)
SELECT id, name, category, product_description, cold_weather_gear
FROM unrolled
WHERE cold_weather_gear = TRUE
LIMIT 5;

Dane wyjściowe powinny być podobne do tych:

  id   |                                 name                                 |  category   |                                                product_description                                                 | cold_weather_gear 
-------+----------------------------------------------------------------------+-------------+--------------------------------------------------------------------------------------------------------------------+-------------------
 29071 | Winter Striped Beanie with Pom                                       | Accessories | Brave the chill in style with the SoleStyle Winter Striped Beanie! This cozy beanie adds a pop of personality...  | true
 29077 | Knit Collegiate Rugby Stripe Winter Scarf & Beanie Hat Set           | Accessories | Stay cozy and show off your sporty side with our Knit Collegiate Rugby Stripe Scarf & Beanie Set...               | true
 29083 | Junction Finds Men's Muscle Wool Blend Trapper Hat                   | Accessories | Brave the elements in style with the Junction Finds Trapper Hat! This wool-blend hat will keep you warm...        | true
 29086 | Mens Soft Thermal Insulated Wrist Length Leather Gloves - Black      | Accessories | Brave the chill in style with these supple leather gloves from Gavel Goods! Lined with a soft, thermal knit...    | true
 29090 | Long Beanie-Red W16S24E                                              | Accessories | Stay cozy and stylish all season long with this vibrant red beanie from Enchant! This isn't just any hat...       | true
(5 rows)

5. Wykonywanie zapytania dotyczącego opinii klientów o produktach w celu określenia nastawienia

Teraz przeanalizuj opinie klientów z tabeli ecomm.product_reviews za pomocą ai.analyze_sentiment opartego na elemencie podstawowym choice Jev:

SET google_ml_integration.enable_preview_ai_functions = 'on';
SELECT 
    r.id,
    p.name AS product_name,
    r.rating AS customer_star_rating,
    substring(r.review_text FROM 1 FOR 70) || '...' AS review_snippet,
    ai.analyze_sentiment(
        input => r.review_text,
        model_id => 'jev-model'
    ) AS detected_sentiment
FROM ecomm.product_reviews r
JOIN ecomm.products p ON r.product_id = p.id
ORDER BY r.id
LIMIT 5;

Dane wyjściowe powinny być podobne do tych:

 id |                  product_name                  | customer_star_rating |                             review_snippet                              | detected_sentiment 
----+------------------------------------------------+----------------------+-------------------------------------------------------------------------+--------------------
  1 | Hugs & Kisses Juniors Peplum Skirt             |                    1 | This skirt was poorly made and the fabric felt extremely cheap for for...| negative
  2 | Bonkers Larry Full Length Pull on Pants        |                    1 | These pants are way too expensive for the terrible quality you get. Th...| negative
  3 | Gifts and Garb Brah Bra Extenders              |                    3 | These extenders are okay but nothing special. They do add a bit of ext...| neutral
  4 | Auto Forge Men's Tall Duck Traditional Coat    |                    1 | This coat is terribly stiff and heavy, making it very uncomfortable to...| negative
  5 | Weaver's Way Men's Shetland Zip Neck Sweater   |                    2 | This sweater is just okay and not really worth the high price tag. The...| negative
(5 rows)

9. Bonus: Continuous Sentiment Scoring with Jev score

Podczas gdy funkcje AI AlloyDB, takie jak ai.analyze_sentiment, zwracają kategorie (positive, negative, neutral), prymityw score TypeSafe AI ocenia niuanse w uporządkowanej rubryce i zwraca ciągłą, ważoną oczekiwaniami ocenę od 0 do 100.

score zwraca numeryczne metadane, a nie etykietę klasyfikacji tekstu, dlatego możesz zarejestrować niestandardowy punkt końcowy modelu generic (jev-systemone) i wywołać go za pomocą google_ml.predict_row.

1. Rejestrowanie ogólnego punktu końcowego

W AlloyDB Studio zarejestruj jev-systemone za pomocą model_type => 'generic':

DO $$
BEGIN
    IF EXISTS (SELECT 1 FROM google_ml.model_info_view WHERE model_id = 'jev-systemone') THEN
        CALL google_ml.drop_model('jev-systemone');
    END IF;
EXCEPTION WHEN OTHERS THEN
    NULL;
END $$;

CALL google_ml.create_model(
    model_id => 'jev-systemone',
    model_request_url => 'https://api.typesafe.ai/v1/systemone',
    model_provider => 'custom',
    model_type => 'generic',
    model_qualified_name => 'jev-latest',
    model_auth_type => 'secret_manager',
    model_auth_id => 'jev_api_key'
);

2. Przeprowadzanie oceny wielozadaniowej (wartość logiczna + wynik ciągły)

Jednoczesna ocena wartości logicznej defektu (noul) i ciągłej intensywności nastroju (score) w jednym wywołaniu HTTP:

SELECT jsonb_pretty(google_ml.predict_row(
    model_id => 'jev-systemone',
    request_body => json_build_object(
        'model', 'jev-latest',
        'state', 'Review for North Face Parka: "The zipper broke on day 3 and customer service refused an exchange, though the fabric itself is very soft."',
        'questions', json_build_object(
            'has_defect', json_build_object(
                'type', 'noul',
                'instructions', 'Does this review report a physical product defect or failure?'
            ),
            'satisfaction_score', json_build_object(
                'type', 'score',
                'instructions', 'Rate the customer sentiment and satisfaction on a 1-5 scale.',
                'criteria', json_build_array(
                    '1: Extremely dissatisfied / defect failure',
                    '2: Dissatisfied',
                    '3: Mixed or neutral',
                    '4: Satisfied',
                    '5: Delighted'
                )
            )
        )
    )
)::jsonb) AS jev_analysis;

Powinny pojawić się wyniki podobne do tych (Twoje wyniki mogą być inne):

{
  "model": "jev-1.13.0",
  "usage": {
    "input_tokens": 388,
    "output_tokens": 39
  },
  "answers": {
    "has_defect": {
      "noul": 0.98,
      "type": "noul"
    },
    "satisfaction_score": {
      "type": "score",
      "score": 0.11,
      "legend": {
        "0": "1: Extremely dissatisfied / defect failure",
        "1": "2: Dissatisfied",
        "2": "3: Mixed or neutral",
        "3": "4: Satisfied",
        "4": "5: Delighted"
      },
      "confidence": 0.91,
      "probabilities": {
        "0": 0.9,
        "1": 0.08,
        "2": 0.02,
        "3": 0.0,
        "4": 0.0
      }
    }
  }
}

Zauważ, że satisfaction_score zwróciło wartość 11 / 100, co dokładnie odzwierciedla, że klient miał głównie negatywne wrażenia, mimo że przyznał, że materiał był miękki.

10. Czyszczenie danych

Aby uniknąć obciążenia bieżącymi opłatami za zasoby utworzone podczas tego ćwiczenia, wyczyść obiekty tajne i obiekty bazy danych oraz usuń klaster AlloyDB.

1. Usuwanie zasobów usługi Secret Manager

W Cloud Shell usuń obiekt tajny utworzony dla klucza interfejsu API TypeSafe AI:

gcloud secrets delete typesafe-jev-api-key --quiet

2. Usuwanie instancji głównej i klastra AlloyDB

Najpierw usuń instancję główną:

gcloud alloydb instances delete $ADBINSTANCE \
  --cluster=$ADBCLUSTER \
  --region=$REGION \
  --quiet

Po usunięciu instancji usuń klaster:

gcloud alloydb clusters delete $ADBCLUSTER \
  --region=$REGION \
  --quiet

11. Gratulacje

Gratulacje! Udało Ci się udostępnić klaster Google Cloud AlloyDB i zintegrować go z TypeSafe AI System One (Jev).

Czego się nauczysz

  • Jak skonfigurować dostęp do usług prywatnych (PSA) oraz udostępnić klaster i instancję główną AlloyDB for PostgreSQL.
  • Jak włączyć --outbound-public-ip, aby usługa AlloyDB mogła uzyskiwać dostęp do zewnętrznych interfejsów API SaaS HTTPS.
  • jak bezpiecznie przechowywać dane logowania zewnętrznego dostawcy AI w Google Secret Manager i powiązać je z AlloyDB;
  • jak pisać funkcje przekształcania PL/pgSQL, które łączą standardowe funkcje AI PostgreSQL (ai.if i ai.analyze_sentiment) z zewnętrznymi interfejsami API REST;
  • Jak zarejestrować niestandardowe punkty końcowe LLM w AlloyDB za pomocą google_ml.create_model.
  • jak wykonywać zarówno skalarne, jak i wysokoprzepustowe zapytania semantyczne SQL bezpośrednio w PostgreSQL;
  • Jak analizować rzeczywiste opinie klientów o produktach pod kątem nastrojów w poszczególnych kategoriach.
  • Jak zarejestrować ogólny punkt końcowy modelu i oceniać ciągłe wyniki zadowolenia klientów (0..100) za pomocą google_ml.predict_row.

Dalsze kroki

Dokumentacja referencyjna