Inhalte zusammenfassen

Die Funktion ai.summarize in AlloyDB for PostgreSQL verwendet Large Language Models (LLMs) wie Gemini, um Eingabetext zu komprimieren und in die wichtigsten Punkte umzuorganisieren. Wenn Sie die Zusammenfassung direkt in SQL ausführen, können Sie wichtige Erkenntnisse aus großen Datasets ohne manuelle Überprüfung extrahieren, die Ausgabelänge durch Angabe von Wort- oder Satzlimits im Prompt steuern und Zeilen asynchron in Batches verarbeiten.

Mit ai.summarize können Sie Besprechungstranskripte in Entscheidungen und Aufgaben zusammenfassen, technische Dokumentation in allgemeine Übersichten zusammenfassen oder Kundensupportprotokolle und Nutzerrezensionen in einheitliche Problemzusammenfassungen aggregieren.

Hinweis

Prüfen Sie, ob Sie die folgenden Anforderungen erfüllen, bevor Sie die Funktion ai.summarize verwenden.

Erweiterung aktivieren

Achten Sie darauf, dass Sie die aktuelle Version der google_ml_integration.enable_preview_ai_functions-Erweiterung (Version 1.6.1 oder höher) mit aktivierter Vorschaufunktion installiert haben.

Verwenden Sie den Befehl SET, um das Flag google_ml_integration.enable_preview_ai_functions in AlloyDB zu aktivieren. Dieses Flag steuert den Zugriff auf KI-Funktionen in der Vorabversion wie ai.summarize.

  1. Achten Sie darauf, dass Ihr google_ml_integration extension die Version 1.6.1 oder höher hat. Sie können die Version mit dem folgenden Befehl prüfen:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Wenn Sie ein Upgrade auf eine Version durchführen müssen, die diese Vorschaufunktionen enthält, rufen Sie Folgendes auf:

    CALL google_ml.upgrade_to_preview_version();

  2. Aktivieren Sie das Flag für die aktuelle Sitzung oder für die gesamte Datenbank. Führen Sie den folgenden Befehl aus, um das Flag für Ihre aktuelle Sitzung zu aktivieren:

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Für diese Änderung ist kein Neustart der Datenbank erforderlich. Der Standardwert dieses Flags ist off.

Beispieltabelle erstellen

Wenn Sie die Beispiele für Zusammenfassungsfunktionen in diesem Dokument nachvollziehen möchten, erstellen Sie eine Tabelle und füllen Sie sie mit den folgenden Filmrezensionen.

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

Einzelnen String zusammenfassen

Verwenden Sie die skalare Version von ai.summarize, um einen einzelnen Textblock zu verarbeiten.

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

Führen Sie die folgende Beispielabfrage aus, um eine prägnante Zusammenfassung von Filmrezensionen zu erhalten:

SELECT ai.summarize(review) FROM movie_reviews;

Hier sehen Sie die Beispielausgabe:

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

In Batches zusammenfassen

Verwenden Sie die arraybasierte Version, um mehrere Datensätze effizient zu verarbeiten.

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.
);

Im folgenden Beispiel wird gezeigt, wie Sie die arraybasierte Version der ai.summarize-Funktion verwenden, um mehrere Texteinträge in einem einzigen Aufruf effizient zu verarbeiten.

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 ;

Hier sehen Sie die Beispielausgabe:

 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."

Mit Cursors zusammenfassen

Mit Cursorn können Sie potenziell große Mengen an Rezensionen effizient verarbeiten, sie an eine KI-Funktion übergeben und die Ergebnisse dann einzeln verarbeiten, um sie wieder in der Datenbank zu speichern.

Im folgenden Beispiel wird gezeigt, wie Sie Cursor mit der Funktion ai.summarize verwenden, um Zeilen aus der Tabelle movie_reviews effizient zu verarbeiten, eine Zusammenfassung für jede Rezension zu generieren und diese Zusammenfassungen in einer neuen Tabelle namens review_summaries zu speichern. Dieser cursorbasierte Ansatz ist nützlich für die Verarbeitung großer Datasets, die möglicherweise zu groß sind, um in einem einzigen Batch verarbeitet zu werden oder auf einmal in den Arbeitsspeicher zu passen.

Für den Parameter input_cursor wird ein REFCURSOR verwendet. Das bedeutet, dass Sie einen Cursornamen angeben müssen, der wie ein Zeiger auf die Ergebnisse einer SQL-Abfrage fungiert. Die Funktion ai.summarize ruft dann Daten von diesem Cursor ab, um sie als Eingabe für die Zusammenfassung zu verwenden.

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

Im folgenden Beispiel wird die Tabelle review_summaries erstellt (falls erforderlich). Anschließend werden Filmrezensionen durchlaufen, für jede Rezension wird mit einer KI-Funktion eine kurze Zusammenfassung generiert und die Zusammenfassungen werden mit den ursprünglichen Rezensions-IDs in der Tabelle gespeichert.

-- 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;

Hier sehen Sie die Beispielausgabe:

 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."

Mit zusätzlichen Anweisungen zusammenfassen

Die folgende SQL-Abfrage übergibt zusätzliche Anweisungen, um die Zusammenfassung zu steuern:

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

Mit einem bestimmten Modell zusammenfassen

Wenn Sie ein Modell angeben möchten, ohne zusätzliche Anweisungen bereitzustellen, müssen Sie die Modell-ID übergeben und explizit in VARCHAR umwandeln, damit sie nicht mit Anweisungen verwechselt wird:

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

Mit zusätzlichen Anweisungen und einem bestimmten Modell zusammenfassen

In der folgenden SQL-Abfrage werden sowohl zusätzliche Anweisungen als auch eine bestimmte Modell-ID übergeben:

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

Zusammenfassung über Zeilen hinweg aggregieren

Die Funktion ai.agg_summarize wird auf mehrere Zeilen in einer Spalte angewendet. Die Werte werden in einem einheitlichen Prompt zusammengefasst, um eine einzige Zusammenfassung für die gesamte Gruppe zu generieren.

In der folgenden SQL-Abfrage wird die Aggregatfunktion ai.agg_summarize verwendet, um für jede movie_id eine einzelne, einheitliche Zusammenfassung basierend auf allen Rezensionen in der Tabelle movie_reviews zu generieren.

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

Im Gegensatz zu ai.summarize, das jede Zeile einzeln zusammenfasst, kombiniert ai.agg_summarize den Text aus mehreren Zeilen zu einer einzigen Eingabe, um eine konsolidierte Zusammenfassung für die gesamte Gruppe von Zeilen zu erstellen.

Hier sehen Sie die Beispielausgabe:

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."

Nächste Schritte