La funzione ai.summarize utilizza modelli linguistici di grandi dimensioni (LLM) come Gemini per riformulare e riorganizzare il testo di input nella sua forma più essenziale. Questa funzione acquisisce la tesi principale di un documento preservando il tono e le sfumature originali dell'autore. Utilizzando questa funzione, puoi estrarre risultati e conclusioni chiave da set di dati di grandi dimensioni senza revisione manuale e controllare la lunghezza dell'output specificando vincoli come il numero di parole o i limiti delle frasi nel prompt. Puoi anche utilizzare l'elaborazione batch o gli snapshot basati su cursore per elaborare milioni di righe in modo asincrono.
La funzione di riassunto dei contenuti AI di AlloyDB supporta vari casi d'uso, inclusi, a titolo esemplificativo, i seguenti:
Trascrizioni delle riunioni: riassumi il testo della conversazione per concentrarti su decisioni e attività.
Documentazione tecnica: condensa metodologie, risultati e implicazioni complessi in panoramiche di alto livello.
Log dell'assistenza clienti: aggrega più recensioni degli utenti o ticket di assistenza in un unico riepilogo unificato dei problemi comuni.
Prima di iniziare
Prima di utilizzare la funzione ai.summarize, assicurati di soddisfare i seguenti requisiti.
Attiva l'estensione
Assicurati di aver installato l'estensione google_ml_integration (versione 1.6.4 o successive) con il motore di query AI abilitato.
Per attivare il flag google_ml_integration.enable_ai_query_engine in AlloyDB Omni, utilizza il comando SET. Questo flag controlla l'accesso alle funzioni AI come ai.summarize.
Assicurati che l'estensione
google_ml_integrationsia la versione 1.6.4 o successive. Puoi controllare la versione eseguendo questo comando:SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';Se devi aggiornare l'estensione, esegui questo comando:
ALTER EXTENSION google_ml_integration UPDATE;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_ai_query_engine = '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 => 'ADDITIONAL_INSTRUCTIONS', -- Optional
model_id => 'MODEL_ID' -- Optional
);
Esegui la seguente query di esempio per fornire un riepilogo conciso delle recensioni dei film:
SELECT id, ai.summarize(review) AS summary 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 => TEXT, -- Optional
batch_size => INT, -- Optional. The default 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 => 'Summarize the following review in max 10 words',
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;
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 => '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."
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."