Résumer le contenu

Sélectionnez une version de la documentation :

La fonction ai.summarize utilise des grands modèles de langage (LLM) tels que Gemini pour reformuler et réorganiser le texte d'entrée dans sa forme la plus essentielle. Cette fonction capture la thèse principale d'un document tout en préservant le ton et les nuances de l'auteur d'origine. À l'aide de cette fonction, vous pouvez extraire les principaux résultats et conclusions de grands ensembles de données sans examen manuel, et contrôler la longueur du résultat en spécifiant des contraintes telles que le nombre de mots ou les limites de phrases dans le prompt. Vous pouvez également utiliser le traitement par lot ou les instantanés basés sur des curseurs pour traiter des millions de lignes de manière asynchrone.

La fonction de résumé de contenu AlloyDB AI est compatible avec différents cas d'utilisation, y compris, mais sans s'y limiter, les suivants :

  • Transcriptions de réunions : résumez le texte conversationnel pour vous concentrer sur les décisions et les tâches à effectuer.
  • Documentation technique : condensez les méthodologies, les résultats et les implications complexes en présentations générales de haut niveau.
  • Journaux d'assistance client : agrégez plusieurs avis d'utilisateurs ou demandes d'assistance en un seul résumé unifié des problèmes courants.

Avant de commencer

Assurez-vous de remplir les conditions 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 l'indicateur google_ml_integration.enable_preview_ai_functions dans AlloyDB Omni, utilisez la commande SET. Cet indicateur contrôle l'accès aux fonctions d'IA en version bêta 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 passer à une version incluant ces fonctions en version bêta, appelez la commande suivante :

    CALL google_ml.upgrade_to_preview_version();

  2. Activez l'indicateur pour la session en cours ou pour l'ensemble de la base de données. Pour activer l'indicateur 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émarrer la base de données. La valeur par défaut de cet indicateur est off.

Créer une table d'exemple

Pour suivre les exemples de la fonction de résumé 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

Résumer 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 de films :

SELECT ai.summarize(review) FROM movie_reviews;

Voici l'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."
...

Résumer 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 l'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."

Résumer à 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 le résumé.

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 de films, génère un résumé concis pour chacun à l'aide d'une fonction AI et stocke les résumés lié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 l'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égation du résumé 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 seul résumé 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 l'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