Resumir conteúdo

A função ai.summarize no AlloyDB para PostgreSQL usa modelos de linguagem grandes (LLMs), como o Gemini, para condensar e reorganizar o texto de entrada nos pontos mais essenciais. Ao executar a sumarização diretamente no SQL, é possível extrair as principais descobertas de grandes conjuntos de dados sem revisão manual, controlar o tamanho da saída especificando limites de palavras ou frases no comando e processar linhas de forma assíncrona em lotes.

Use o ai.summarize para condensar transcrições de reuniões em decisões e ações necessárias, resumir documentação técnica em visões gerais de alto nível ou agregar registros de suporte ao cliente e avaliações de usuários em resumos de problemas unificados.

Antes de começar

Verifique se você atende aos seguintes requisitos antes de usar a função ai.summarize.

Ativar a extensão

Verifique se você tem a versão mais recente da extensão google_ml_integration.enable_preview_ai_functions (versão 1.6.1 ou mais recente) instalada com a funcionalidade de pré-lançamento ativada.

Para ativar a flag google_ml_integration.enable_preview_ai_functions no AlloyDB, use o comando SET. Essa flag controla o acesso a funções de IA em pré-lançamento, como ai.summarize.

  1. Verifique se o google_ml_integration extension é a versão 1.6.1 ou mais recente. Para verificar a versão, execute o seguinte:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Se você precisar fazer upgrade para uma versão que inclua essas funções de pré-lançamento, chame o seguinte:

    CALL google_ml.upgrade_to_preview_version();

  2. Ative a flag para a sessão atual ou para todo o banco de dados. Para ativar a flag na sessão atual, execute o seguinte:

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Essa mudança não exige a reinicialização do banco de dados. O valor padrão dessa flag é off.

Criar uma tabela de exemplo

Para seguir os exemplos de função de resumo neste documento, crie uma tabela e preencha-a com as seguintes avaliações de filmes.

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

Resumir uma única string

Para processar um único bloco de texto, use a versão escalar de ai.summarize.

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

Execute o exemplo de consulta a seguir para fornecer um resumo conciso das avaliações de filmes:

SELECT ai.summarize(review) FROM movie_reviews;

Veja um exemplo de saída:

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

Resumir em lotes

Para processar vários registros de forma eficiente, use a versão baseada em matriz.

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

O exemplo a seguir mostra como usar a versão baseada em matriz da função ai.summarize para processar com eficiência vários registros de texto em uma única chamada.

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 ;

Veja um exemplo de saída:

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

Resumir usando cursores

É possível usar cursores para lidar de forma eficiente com conjuntos potencialmente grandes de avaliações, alimentando-os em uma função de IA e processando os resultados um por um para armazená-los de volta no banco de dados.

O exemplo a seguir mostra como usar cursores com a função ai.summarize para processar com eficiência as linhas da tabela movie_reviews, gerar um resumo para cada avaliação e armazenar esses resumos em uma nova tabela chamada review_summaries. Essa abordagem baseada em cursor é útil para lidar com grandes conjuntos de dados que podem ser grandes demais para serem processados em um único lote ou caber na memória de uma só vez.

O parâmetro input_cursor usa um REFCURSOR. Isso significa que você precisa fornecer um nome de cursor, que funciona como um ponteiro para os resultados de uma consulta SQL. A função ai.summarize busca dados desse cursor para usar como entrada para o resumo.

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

O exemplo a seguir cria uma tabela review_summaries (se necessário), itera pelas avaliações de filmes, gera um resumo conciso para cada uma usando uma função de IA e armazena os resumos vinculados aos IDs de avaliação originais na tabela.

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

Veja um exemplo de saída:

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

Resumir com instruções adicionais

A consulta SQL a seguir transmite instruções adicionais para orientar o resumo:

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

Resumir com um modelo específico

Para especificar um modelo sem fornecer outras instruções, transmita o ID do modelo e o converta explicitamente em VARCHAR para que ele não seja confundido com instruções:

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

Resumir com instruções adicionais e um modelo específico

A consulta SQL a seguir transmite instruções adicionais e um ID de modelo específico:

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

Resumo agregado em linhas

A função ai.agg_summarize opera em várias linhas de uma coluna. Ele agrega valores em um comando unificado para gerar um único resumo para todo o grupo.

A consulta SQL a seguir usa a função de agregação ai.agg_summarize para gerar um único resumo unificado para cada movie_id com base em todas as avaliações na tabela movie_reviews.

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

Ao contrário de ai.summarize, que resume cada linha individualmente, ai.agg_summarize combina o texto de várias linhas em uma única entrada para produzir um resumo consolidado para todo o grupo de linhas.

Veja um exemplo de saída:

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

A seguir