Résumer le contenu

La fonction ai.summarize utilise de grands modèles de langage (LLM) comme Gemini pour reformuler et réorganiser le texte d'entrée sous 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. Cette fonction vous permet d'extraire les principales conclusions et les principaux résultats d'ensembles de données volumineux sans examen manuel. Vous pouvez également contrôler la longueur de la sortie en spécifiant des contraintes telles que le nombre de mots ou la limite de phrases dans la requête. 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 synthèse de contenu AlloyDB/AI est compatible avec différents cas d'utilisation, y compris, mais sans s'y limiter :

  • Transcriptions de réunions : résumez le texte de conversation pour vous concentrer sur les décisions et les tâches à effectuer.
  • Documentation technique : résumer des méthodologies, des résultats et des implications complexes en présentations générales.
  • Journaux du service client : regroupez plusieurs avis d'utilisateurs ou demandes d'assistance dans un seul récapitulatif unifié des problèmes courants.

Avant de commencer

Avant d'utiliser la fonction ai.summarize, assurez-vous de remplir les conditions suivantes.

Activer l'extension

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

Pour activer l'option google_ml_integration.enable_preview_ai_functions dans AlloyDB, utilisez la commande SET. Cet indicateur contrôle l'accès aux fonctions d'IA en aperçu, comme ai.summarize.

  1. Assurez-vous que votre google_ml_integration extension est en 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 qui inclut ces fonctions d'aperçu, appelez ce qui suit :

    CALL google_ml.upgrade_to_preview_version();

  2. Activez le signalement pour la session en cours ou pour l'ensemble de la base de données. Pour activer le flag pour votre session actuelle, 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 ce flag est off.

Créer un exemple de tableau

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

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

Résumer par lots

Pour traiter plusieurs enregistrements efficacement, 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 à nouveau 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écapitulatif pour chaque avis et stocker ces récapitulatifs dans une nouvelle table appelée review_summaries. Cette approche basée sur les curseurs est utile pour gérer les 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 sert de 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 d'IA 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."

Synthèse agrégée sur plusieurs lignes

La fonction ai.agg_summarize s'applique à plusieurs lignes d'une colonne. Il agrège les valeurs dans une requête unifiée pour générer un résumé unique 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."

Étapes suivantes