Riassumere i contenuti

La funzione ai.summarize in AlloyDB per PostgreSQL utilizza modelli linguistici di grandi dimensioni (LLM) come Gemini per condensare e riorganizzare il testo di input nei suoi punti più essenziali. Eseguendo la sintesi direttamente in SQL, puoi estrarre i risultati chiave da set di dati di grandi dimensioni senza revisione manuale, controllare la lunghezza dell'output specificando i limiti di parole o frasi nel prompt ed elaborare le righe in modo asincrono in batch.

Puoi utilizzare ai.summarize per condensare le trascrizioni delle riunioni in decisioni e attività, riassumere la documentazione tecnica in panoramiche generali o aggregare i log dell'assistenza clienti e le recensioni degli utenti in riepiloghi unificati dei problemi.

Prima di iniziare

Prima di utilizzare la funzione ai.summarize, assicurati di soddisfare i seguenti requisiti.

Attiva l'estensione

Assicurati di aver installato l'ultima versione dell'estensione google_ml_integration.enable_preview_ai_functions (versione 1.6.1 o successive) con la funzionalità di anteprima attivata.

Per abilitare il flag google_ml_integration.enable_preview_ai_functions in AlloyDB, utilizza il comando SET. Questo flag controlla l'accesso alle funzioni AI in anteprima come ai.summarize.

  1. Assicurati che la versione di google_ml_integration extension sia 1.6.1 o successiva. Puoi controllare la versione eseguendo questo comando:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Se devi eseguire l'upgrade a una versione che include queste funzioni in anteprima, chiama quanto segue:

    CALL google_ml.upgrade_to_preview_version();

  2. Attiva il flag per la sessione corrente o per l'intero database. Per attivare il flag per la sessione corrente, esegui questo comando:

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Questa modifica non richiede il riavvio del database. Il valore predefinito di questo flag è off.

Crea una tabella di esempio

Per seguire gli esempi di funzioni di riassunto in questo documento, crea una tabella e compilala con le seguenti recensioni di film.

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

Riassumi una singola stringa

Per elaborare un singolo blocco di testo, utilizza la versione scalare di ai.summarize.

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

Esegui la seguente query di esempio per fornire un riepilogo conciso delle recensioni dei film:

SELECT ai.summarize(review) FROM movie_reviews;

Di seguito è riportato l'output di esempio:

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

Riassumi in batch

Per elaborare più record in modo efficiente, utilizza la versione basata su 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.
);

L'esempio seguente mostra come utilizzare la versione basata su array della funzione ai.summarize per elaborare in modo efficiente più record di testo in una singola chiamata.

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 ;

Di seguito è riportato l'output di esempio:

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

Riassumi utilizzando i cursori

Puoi utilizzare i cursori per gestire in modo efficiente insiemi potenzialmente ampi di recensioni, inserendoli in una funzione AI e poi elaborando i risultati uno alla volta per archiviarli nuovamente nel database.

L'esempio seguente mostra come utilizzare i cursori con la funzione ai.summarize per elaborare in modo efficiente le righe della tabella movie_reviews, generare un riepilogo per ogni recensione e archiviare questi riepiloghi in una nuova tabella denominata review_summaries. Questo approccio basato su cursori è utile per gestire set di dati di grandi dimensioni che potrebbero essere troppo grandi per essere elaborati in un unico batch o per essere caricati in memoria tutti insieme.

Il parametro input_cursor accetta un REFCURSOR. Ciò significa che devi fornire un nome del cursore, che funge da puntatore ai risultati di una query SQL. La funzione ai.summarize recupera quindi i dati da questo cursore per utilizzarli come input per il riassunto.

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

L'esempio seguente crea una tabella review_summaries (se necessario), quindi esegue l'iterazione delle recensioni dei film, genera un riepilogo conciso per ciascuna utilizzando una funzione AI e archivia i riepiloghi collegati ai relativi ID recensione originali nella tabella.

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

Di seguito è riportato l'output di esempio:

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

Riassumi con istruzioni aggiuntive

La seguente query SQL passa istruzioni aggiuntive per guidare il riepilogo:

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

Riassumi con un modello specifico

Per specificare un modello senza fornire istruzioni aggiuntive, devi passare l'ID modello ed eseguirne il cast esplicito in VARCHAR in modo che non venga scambiato per istruzioni:

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

Riassumi con istruzioni aggiuntive e un modello specifico

La seguente query SQL passa sia istruzioni aggiuntive sia un ID modello specifico:

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

Riepilogo aggregato tra le righe

La funzione ai.agg_summarize opera su più righe di una colonna. Aggrega i valori in un prompt unificato per generare un unico riepilogo per l'intero gruppo.

La seguente query SQL utilizza la funzione di aggregazione ai.agg_summarize per generare un unico riepilogo unificato per ogni movie_id in base a tutte le recensioni nella tabella movie_reviews.

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

A differenza di ai.summarize, che riassume ogni riga singolarmente, ai.agg_summarize combina il testo di più righe in un unico input per produrre un riepilogo consolidato per l'intero gruppo di righe.

Di seguito è riportato l'output di esempio:

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

Passaggi successivi