Resume contenido

Selecciona una versión de la documentación:

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 principal de un documento y, al mismo tiempo, conserva el tono y los matices originales del autor. Con esta función, puedes extraer hallazgos y conclusiones clave de conjuntos de datos masivos sin revisión manual 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: Resume el texto de la conversación para enfocarte en las decisiones y los elementos de acción.

  • Documentación técnica: Condensa metodologías, resultados y consecuencias 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 extensión google_ml_integration (versión 1.6.4 o posterior) con el motor de consultas de IA habilitado.

Para habilitar la marca google_ml_integration.enable_ai_query_engine en AlloyDB Omni, usa el comando SET. Este parámetro controla el acceso a las funciones de IA, como ai.summarize.

  1. Asegúrate de que la extensión google_ml_integration sea la versión 1.6.4 o una posterior. Para verificar la versión, ejecuta lo siguiente:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Si necesitas actualizar la extensión, ejecuta el siguiente comando:

    ALTER EXTENSION google_ml_integration UPDATE;

  2. Habilita la marca para la sesión actual o para toda la base de datos. Para habilitar la marca en tu sesión actual, ejecuta lo siguiente:

    SET google_ml_integration.enable_ai_query_engine = '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 funciones de resumen de este documento, crea una tabla y complétala con las siguientes opiniones 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

Resume una sola cadena

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

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

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

SELECT id, ai.summarize(review) AS summary FROM movie_reviews;

El siguiente es 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."
...

Resume en lotes

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

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

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

El siguiente es 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."

Resume el uso de cursores

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

En el siguiente ejemplo, se muestra cómo usar cursores con la función ai.summarize para procesar de forma eficiente las filas de la tabla movie_reviews, generar un resumen de cada opinión y almacenar estos resúmenes en una tabla nueva llamada review_summaries. Este enfoque basado en cursores es útil para controlar conjuntos de datos grandes que podrían ser demasiado grandes para procesarlos en un solo lote o para que quepan 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(
  input_cursor REFCURSOR,
  additional_instructions TEXT DEFAULT NULL,
  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 iteran las opiniones de películas, se genera un resumen conciso para cada una con una función de 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 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;

El siguiente es 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 agregado en todas 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.

El siguiente es 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?