Meringkas konten

Fungsi ai.summarize di AlloyDB untuk PostgreSQL menggunakan model bahasa besar (LLM) seperti Gemini untuk meringkas dan mengatur ulang teks input menjadi poin-poin yang paling penting. Dengan menjalankan peringkasan langsung di SQL, Anda dapat mengekstrak temuan penting dari set data besar tanpa peninjauan manual, mengontrol panjang output dengan menentukan batas kata atau kalimat dalam perintah, dan memproses baris secara asinkron dalam batch.

Anda dapat menggunakan ai.summarize untuk meringkas transkrip rapat menjadi keputusan dan item tindakan, meringkas dokumentasi teknis menjadi ringkasan tingkat tinggi, atau menggabungkan log dukungan pelanggan dan ulasan pengguna menjadi ringkasan masalah yang terpadu.

Sebelum memulai

Pastikan Anda memenuhi persyaratan berikut sebelum menggunakan fungsi ai.summarize.

Mengaktifkan ekstensi

Pastikan Anda telah menginstal ekstensi google_ml_integration.enable_preview_ai_functions versi terbaru (versi 1.6.1 atau yang lebih baru) dengan fungsi Pratinjau diaktifkan.

Untuk mengaktifkan flag google_ml_integration.enable_preview_ai_functions di AlloyDB, gunakan perintah SET. Flag ini mengontrol akses ke fungsi AI pratinjau seperti ai.summarize.

  1. Pastikan google_ml_integration extension Anda adalah versi 1.6.1 atau yang lebih tinggi. Anda dapat memeriksa versi dengan menjalankan perintah berikut:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Jika Anda perlu mengupgrade ke versi yang menyertakan fungsi pratinjau ini, panggil hal berikut:

    CALL google_ml.upgrade_to_preview_version();

  2. Aktifkan flag untuk sesi saat ini atau untuk seluruh database. Untuk mengaktifkan flag untuk sesi Anda saat ini, jalankan perintah berikut:

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Perubahan ini tidak memerlukan mulai ulang database. Nilai default flag ini adalah off.

Membuat tabel contoh

Untuk mengikuti contoh fungsi ringkasan dalam dokumen ini, buat tabel dan isi dengan ulasan film berikut.

CREATE TABLE movie_reviews (
    id INT PRIMARY KEY,
    movie_id INT,
    review TEXT
);

INSERT INTO movie_reviews (id, movie_id, review) VALUES
(1, 1, 'The Midnight Echo represents a masterclass in atmospheric tension. The cinematography captures the isolation of the frozen tundra perfectly while the lead actor delivers a superb performance. Although the pacing slows down significantly in the second act, the final twist remains unexpected. This is a truly remarkable experience.'),
(2, 1, 'Neon Velocity delivers high octane action but lacks the narrative depth required to make the stakes feel real. The visual effects are undeniably stunning, creating a vibrant cyberpunk world that pops off the screen. However, the dialogue feels cliched and the secondary characters are thin. This film is a shallow blockbuster.');

-- more rows are present in this table

Meringkas satu string

Untuk memproses satu blok teks, gunakan versi skalar ai.summarize.

SELECT ai.summarize(
  input => 'TEXT_CONTENT',
  additional_instructions => 'INSTRUCTIONS', -- Optional
  model_id => 'MODEL_ID' -- Optional
);

Jalankan contoh kueri berikut untuk memberikan ringkasan singkat ulasan film:

SELECT ai.summarize(review) FROM movie_reviews;

Berikut adalah contoh output:

 id |                         summary
----+-----------------------------------------------------------
  1 | "Atmospheric thriller with a haunting performance and shocking twist."
  2 | "Visually stunning cyberpunk action film lacks narrative depth."
...

Meringkas dalam batch

Untuk memproses beberapa data secara efisien, gunakan versi berbasis array.

SELECT ai.summarize(
  inputs => TEXT[],
  additional_instructions => 'INSTRUCTIONS', -- Optional
  batch_size => INT, -- Optional. The default value is 10.
  model_id => VARCHAR(100) -- Optional. The default value is gemini-3.5-flash-lite.
);

Contoh berikut menunjukkan cara menggunakan versi berbasis array dari fungsi ai.summarize untuk memproses beberapa kumpulan teks secara efisien dalam satu panggilan.

WITH summarized_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.summarize(
    inputs => array_agg(review ORDER BY id),
    additional_instructions =>
      'Please summarize this in max 10 words, review : ',
    batch_size => 15
  ) as summaries
FROM movie_reviews
),
correlated_results AS (
    SELECT ids[i] as ID, summaries[i] as summary
    FROM summarized_results,
    generate_series(1, array_length(ids, 1)) AS i
)
SELECT movie_reviews.id, correlated_results.summary as summary
FROM movie_reviews
JOIN correlated_results ON movie_reviews.id = correlated_results.id
ORDER BY movie_reviews.id DESC ;

Berikut adalah contoh output:

 id | summary
---+----------------------------------------------------------------------------
  1 | "Masterclass in tension, haunting performance with a twist."
  2 | "High octane action, stunning visuals, shallow blockbuster."
  3 | "Gentle, moving exploration of  emotional honesty."

Meringkas menggunakan kursor

Anda dapat menggunakan kursor untuk menangani kumpulan ulasan yang berpotensi besar secara efisien, memasukkannya ke dalam fungsi AI, lalu memproses hasilnya satu per satu untuk menyimpannya kembali ke dalam database.

Contoh berikut menunjukkan cara menggunakan kursor dengan fungsi ai.summarize untuk memproses baris dari tabel movie_reviews secara efisien, membuat ringkasan untuk setiap ulasan, dan menyimpan ringkasan ini dalam tabel baru bernama review_summaries. Pendekatan berbasis kursor ini berguna untuk menangani set data besar yang mungkin terlalu besar untuk diproses dalam satu batch atau dimuat ke dalam memori sekaligus.

Parameter input_cursor menggunakan REFCURSOR. Artinya, Anda perlu memberikan nama kursor, yang bertindak seperti pointer ke hasil kueri SQL. Fungsi ai.summarize kemudian mengambil data dari kursor ini untuk digunakan sebagai input untuk ringkasan.

CREATE OR REPLACE FUNCTION ai.summarize(
  input_cursor REFCURSOR,
  additional_instructions TEXT DEFAULT NULL,
  batch_size INT DEFAULT NULL,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS REFCURSOR

Contoh berikut membuat tabel review_summaries (jika diperlukan), lalu melakukan iterasi melalui ulasan film, membuat ringkasan singkat untuk setiap ulasan menggunakan fungsi AI, dan menyimpan ringkasan yang ditautkan ke ID ulasan aslinya dalam tabel.

-- Create a table to store the results
CREATE TABLE IF NOT EXISTS review_summaries (
    review_id INT, 
    summary_text TEXT
);

DO $$
DECLARE
    -- Use descriptive cursor and variable names
    review_cursor   REFCURSOR;
    result_record   RECORD;
    cursor_response  REFCURSOR;
    id_array        INT[];
    idx             INT := 1;
BEGIN
    -- 1. Open cursor for the input text
    OPEN review_cursor FOR
        SELECT review AS input FROM movie_reviews ORDER BY id;

    -- 2. Call the AI summarize function
    cursor_response := ai.summarize(
        input_cursor            => review_cursor,
        additional_instructions => 'Please summarize the following review in max 10 words: '
    );

    -- 3. Map IDs into an array to maintain relational integrity during the loop
    SELECT ARRAY_AGG(id ORDER BY id) INTO id_array FROM movie_reviews;

    -- 4. Iterate through AI results and insert into the results table
    LOOP
        FETCH cursor_response INTO result_record;
        EXIT WHEN NOT FOUND;

        INSERT INTO review_summaries (review_id, summary_text)
        VALUES (id_array[idx], result_record.output);

        idx := idx + 1;
    END LOOP;

    -- 5. Clean up cursors
    CLOSE review_cursor;
    CLOSE cursor_response;
END;
$$;

-- Verify results
SELECT * FROM review_summaries;

Berikut adalah contoh output:

 review_id | summary_text
-----------+---------------------------------------------------------------------------
         1 | "Masterclass in atmospheric tension with haunting performance, devastating twist."
         2 | "High octane action, stunning visuals, but shallow blockbuster."
         3 | "Gentle, moving exploration of grief with poetic screenplay."

Meringkas dengan petunjuk tambahan

Kueri SQL berikut meneruskan petunjuk tambahan untuk memandu ringkasan:

SELECT ai.agg_summarize(review, 'Please summarize this within 10 words') FROM movie_reviews GROUP BY movie_id;

Membuat ringkasan dengan model tertentu

Untuk menentukan model tanpa memberikan petunjuk tambahan, Anda harus meneruskan ID model dan mentransmisikannya secara eksplisit ke VARCHAR agar tidak disalahartikan sebagai petunjuk:

SELECT ai.agg_summarize(review, 'gemini-3.5-flash-lite'::VARCHAR) FROM movie_reviews GROUP BY movie_id;

Membuat ringkasan dengan petunjuk tambahan dan model tertentu

Kueri SQL berikut meneruskan petunjuk tambahan dan ID model tertentu:

SELECT ai.agg_summarize(review, 'Please summarize this within 10 words', 'gemini-3.5-flash-lite') FROM movie_reviews GROUP BY movie_id;

Ringkasan gabungan di seluruh baris

Fungsi ai.agg_summarize beroperasi di beberapa baris dalam satu kolom. Fungsi ini menggabungkan nilai ke dalam perintah terpadu untuk menghasilkan satu ringkasan untuk seluruh grup.

Kueri SQL berikut menggunakan fungsi agregat ai.agg_summarize untuk menghasilkan satu ringkasan terpadu untuk setiap movie_id berdasarkan semua ulasan dalam tabel movie_reviews.

SELECT ai.agg_summarize(review) FROM movie_reviews GROUP BY movie_id;

Tidak seperti ai.summarize, yang meringkas setiap baris satu per satu, ai.agg_summarize menggabungkan teks dari beberapa baris menjadi satu input untuk menghasilkan satu ringkasan gabungan untuk seluruh grup baris.

Berikut adalah contoh output:

agg_summarize
"The Midnight Echo is a masterclass in atmospheric tension, featuring haunting performances and stunning cinematography, though its pacing falters in the second act before a final twist. Neon Velocity offers stunning visual effects and high-octane action within a vibrant cyberpunk world, but suffers from shallow narrative depth, cliched dialogue, and underdeveloped characters. Garden of Whispers is a gentle, moving, and emotionally honest exploration of and life, characterized by poetic screenwriting and natural performances. Shadow Protocol ambitiously attempts to reinvent the spy thriller with a non-linear narrative and precise action, but ultimately confuses the audience and presents a derivative central mystery. The Last Alchemist uniquely blends historical drama with subtle fantasy, boasting meticulous production design and electric chemistry between its protagonists."

Langkah berikutnya