Resume contenido

La función ai.summarize utiliza modelos de lenguaje grandes (LLM) como Gemini para reformular y reorganizar el texto de entrada en su forma más esencial. Esta función captura la tesis central de un documento y conserva el tono y los matices originales del autor. Con esta función, puedes extraer conclusiones y hallazgos clave de conjuntos de datos masivos sin necesidad de realizar revisiones manuales, y controlar la longitud del resultado especificando restricciones, como recuentos de palabras o límites de oraciones en la instrucción. También puedes usar el procesamiento por lotes o las instantáneas basadas en cursores para procesar millones de filas de forma asíncrona.

La función de resumen de contenido de AlloyDB AI admite varios casos de uso, incluidos, sin limitaciones, los siguientes:

  • Transcripciones de reuniones: Resumir el texto conversacional para centrarse en las decisiones y los elementos de acción
  • Documentación técnica: Condensa la metodología, los resultados y las implicaciones complejos en descripciones generales de alto nivel.
  • Registros de asistencia al cliente: Agrega varias opiniones de usuarios o tickets de asistencia en un solo resumen unificado de problemas comunes.

Antes de comenzar

Asegúrate de cumplir con los siguientes requisitos antes de usar la función ai.summarize.

Habilita la extensión

Asegúrate de tener instalada la versión más reciente de la extensión google_ml_integration.enable_preview_ai_functions (versión 1.5.7 o posterior) con la función de vista previa habilitada.

Para habilitar la marca google_ml_integration.enable_preview_ai_functions en AlloyDB, usa el comando SET. Esta marca controla el acceso a las funciones potenciadas por IA en versión preliminar, como ai.summarize.

  1. Asegúrate de que tu google_ml_integration extension sea la versión 1.5.7 o una posterior. Para verificar la versión, ejecuta el siguiente comando:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Si necesitas actualizar a una versión que incluya estas funciones en versión preliminar, llama a lo siguiente:

    CALL google_ml.upgrade_to_preview_version();

  2. Habilita la marca para la sesión actual o para toda la base de datos. Para habilitar el parámetro para tu sesión actual, ejecuta el siguiente comando:

    SET google_ml_integration.enable_preview_ai_functions = 'on';

    Este cambio no requiere que se reinicie la base de datos. El valor predeterminado de esta marca es off.

Crea una tabla de ejemplo

Para seguir los ejemplos de la función de resumen de este documento, crea una tabla y complétala con las siguientes reseñas de películas.

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

Cómo resumir una sola cadena

Para procesar un solo bloque de texto, usa la versión escalar de ai.summarize.

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

Ejecuta la siguiente consulta de ejemplo para proporcionar un resumen conciso de las opiniones sobre películas:

SELECT ai.summarize(review) FROM movie_reviews;

A continuación, se muestra el resultado de ejemplo:

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

Resumir en lotes

Para procesar varios registros de manera eficiente, usa la versión basada en arrays.

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

En el siguiente ejemplo, se muestra cómo usar la versión basada en arrays de la función ai.summarize para procesar de manera eficiente varios registros de texto en una sola llamada.

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 ;

A continuación, se muestra el resultado de ejemplo:

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

Cómo resumir con cursores

Puedes usar cursores para controlar de manera eficiente conjuntos de opiniones potencialmente grandes, ingresarlos en una función IA y, luego, procesar los resultados uno por uno para almacenarlos nuevamente en la base de datos.

En el siguiente ejemplo, se muestra cómo usar cursores con la función ai.summarize para procesar de manera eficiente las filas de la tabla movie_reviews, generar un resumen para cada opinión y almacenar estos resúmenes en una tabla nueva llamada review_summaries. Este enfoque basado en cursores es útil para controlar grandes conjuntos de datos que podrían ser demasiado grandes para procesarse en un solo lote o caber en la memoria de una sola vez.

El parámetro input_cursor toma un REFCURSOR. Esto significa que debes proporcionar un nombre de cursor, que actúa como un puntero a los resultados de una consulta en SQL. Luego, la función ai.summarize recupera datos de este cursor para usarlos como entrada para el resumen.

CREATE OR REPLACE FUNCTION ai.summarize(
  prompt TEXT,
  input_cursor REFCURSOR,
  batch_size INT DEFAULT NULL,
  model_id VARCHAR(100) DEFAULT NULL)
RETURNS REFCURSOR

En el siguiente ejemplo, se crea una tabla review_summaries (si es necesario), luego se itera a través de las opiniones sobre películas, se genera un resumen conciso para cada una con una función IA y se almacenan los resúmenes vinculados a sus IDs de opinión originales en la tabla.

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

A continuación, se muestra el resultado de ejemplo:

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

Resumen de agregación en las filas

La función ai.agg_summarize opera en varias filas de una columna. Agrega valores en una instrucción unificada para generar un solo resumen para todo el grupo.

La siguiente consulta en SQL usa la función de agregación ai.agg_summarize para generar un solo resumen unificado para cada movie_id en función de todas las opiniones de la tabla movie_reviews.

select ai.agg_summarize(review) from movie_reviews group by movie_id;

A diferencia de ai.summarize, que resume cada fila de forma individual, ai.agg_summarize combina el texto de varias filas en una sola entrada para producir un resumen consolidado para todo el grupo de filas.

A continuación, se muestra el resultado de ejemplo:

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

¿Qué sigue?