Résumer le contenu

La fonction ai.summarize d'AlloyDB pour PostgreSQL utilise de grands modèles de langage (LLM) tels que Gemini pour condenser et réorganiser le texte d'entrée en ses points les plus essentiels. En exécutant la synthèse directement dans SQL, vous pouvez extraire les principales conclusions de grands ensembles de données sans examen manuel, contrôler la longueur de la sortie en spécifiant des limites de mots ou de phrases dans l'invite, et traiter les lignes de manière asynchrone par lots.

Vous pouvez utiliser ai.summarize pour condenser les transcriptions de réunions en décisions et en éléments d'action, résumer la documentation technique en présentations générales ou agréger les journaux d'assistance client et les avis des utilisateurs en résumés de problèmes unifiés.

Avant de commencer

Assurez-vous de répondre aux exigences suivantes avant d'utiliser la fonction ai.summarize.

Activer l'extension

Assurez-vous que la dernière version de l'extension google_ml_integration.enable_preview_ai_functions (version 1.5.7 ou ultérieure) est installée et que la fonctionnalité d'aperçu est activée.

Pour activer le flag google_ml_integration.enable_preview_ai_functions dans AlloyDB, utilisez la commande SET. Ce flag contrôle l'accès aux fonctions AI en version preview, telles que ai.summarize.

  1. Assurez-vous que votre google_ml_integration extension est de la version 1.5.7 ou ultérieure. Vous pouvez vérifier la version en exécutant la commande suivante :

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Si vous devez effectuer une mise à niveau vers une version incluant ces fonctions en version bêta, appelez la commande suivante :

    CALL google_ml.upgrade_to_preview_version();

  2. Activez le flag pour la session en cours ou pour l'ensemble de la base de données. Pour activer le flag pour votre session en cours, exécutez la commande suivante :

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Cette modification ne nécessite pas de redémarrage de la base de données. La valeur par défaut de ce flag est off.

Créer une table d'exemple

Pour suivre les exemples de fonction de synthèse de ce document, créez une table et remplissez-la avec les avis de films suivants.

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

Synthétiser une seule chaîne

Pour traiter un seul bloc de texte, utilisez la version scalaire de ai.summarize.

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

Exécutez l'exemple de requête suivant pour obtenir un résumé concis des avis sur les films :

SELECT ai.summarize(review) FROM movie_reviews;

Voici un exemple de résultat :

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

Synthétiser par lots

Pour traiter efficacement plusieurs enregistrements, utilisez la version basée sur un tableau.

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

L'exemple suivant montre comment utiliser la version basée sur un tableau de la fonction ai.summarize pour traiter efficacement plusieurs enregistrements de texte en un seul appel.

WITH summarized_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.summarize(
    prompts => array_agg( 'Please summarize this in max 10 words, review : ' || review
      ORDER BY id),
    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 ;

Voici un exemple de résultat :

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

Synthétiser à l'aide de curseurs

Vous pouvez utiliser des curseurs pour gérer efficacement des ensembles d'avis potentiellement volumineux, les transmettre à une fonction d'IA, puis traiter les résultats un par un pour les stocker dans la base de données.

L'exemple suivant montre comment utiliser des curseurs avec la fonction ai.summarize pour traiter efficacement les lignes de la table movie_reviews, générer un résumé pour chaque avis et stocker ces résumés dans une nouvelle table appelée review_summaries. Cette approche basée sur un curseur est utile pour gérer de grands ensembles de données qui peuvent être trop volumineux pour être traités en un seul lot ou pour tenir en mémoire en une seule fois.

Le paramètre input_cursor accepte un REFCURSOR. Cela signifie que vous devez fournir un nom de curseur, qui agit comme un pointeur vers les résultats d'une requête SQL. La fonction ai.summarize récupère ensuite les données de ce curseur pour les utiliser comme entrée pour la synthèse.

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

L'exemple suivant crée une table review_summaries (si nécessaire), puis parcourt les avis sur les films, génère un résumé concis pour chacun à l'aide d'une fonction AI et stocke les résumés associés à leurs ID d'avis d'origine dans la table.

-- 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 prompt FROM movie_reviews ORDER BY id;

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

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

Voici un exemple de résultat :

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

Agréger la synthèse sur plusieurs lignes

La fonction ai.agg_summarize fonctionne sur plusieurs lignes d'une colonne. Elle agrège les valeurs dans une invite unifiée pour générer un seul résumé pour l'ensemble du groupe.

La requête SQL suivante utilise la fonction d'agrégation ai.agg_summarize pour générer un résumé unique et unifié pour chaque movie_id en fonction de tous les avis de la table movie_reviews.

select ai.agg_summarize(review) from movie_reviews group by movie_id;

Contrairement à ai.summarize, qui résume chaque ligne individuellement, ai.agg_summarize combine le texte de plusieurs lignes en une seule entrée pour produire un résumé consolidé pour l'ensemble du groupe de lignes.

Voici un exemple de résultat :

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

Étape suivante