Compactação de Contexto

À medida que um agente ADK é executado, ele acumula contexto — mensagens do usuário, respostas de ferramentas e conteúdo gerado. Conforme esse contexto cresce, os tempos de processamento de LLM aumentam, pois mais dados são enviados a cada solicitação. A compactação de contexto resolve isso resumindo eventos mais antigos usando uma abordagem de janela deslizante.

Como Funciona

A compactação de contexto usa uma janela deslizante para resumir periodicamente eventos de conversa mais antigos dentro de uma sessão. Quando o número de invocações concluídas atinge o intervalo configurado, o resumidor comprime os eventos mais antigos em um único evento de resumo.

Invocations 1-3: [event1, event2, event3] → Summarized into "Summary A"
Invocations 4-6: [Summary A, event3, event4, event5, event6] → Summarized into "Summary B"

O parâmetro overlap_size controla quantos eventos da janela anterior são transferidos para o próximo resumo, preservando a continuidade.

Configuração

Adicione a compactação à configuração do seu runner:

use adk_agent::LlmEventSummarizer;
use adk_runner::{Runner, RunnerConfig, EventsCompactionConfig};
use std::sync::Arc;

// Use any LLM for summarization (a fast, cheap model works well)
let summarizer_llm = Arc::new(my_model);
let summarizer = Arc::new(LlmEventSummarizer::new(summarizer_llm));

let runner = Runner::new(RunnerConfig {
    app_name: "my_app".to_string(),
    agent: root_agent,
    session_service: sessions,
    artifact_service: None,
    memory_service: None,
    plugin_manager: None,
    run_config: None,
    compaction_config: Some(EventsCompactionConfig {
        compaction_interval: 3,  // Compact every 3 invocations
        overlap_size: 1,         // Keep 1 prior invocation for context
        summarizer,
    }),
})?;

Parâmetros de Configuração

Resumidor personalizado

Você pode personalizar o prompt de resumo:

let summarizer = LlmEventSummarizer::new(llm)
    .with_prompt_template(
        "Summarize this conversation focusing on action items \
         and decisions:\n\n{conversation_history}"
    );

Ou implementar BaseEventsSummarizer para obter controle total:

use adk_core::{BaseEventsSummarizer, Event, Result};
use async_trait::async_trait;

struct MySummarizer;

#[async_trait]
impl BaseEventsSummarizer for MySummarizer {
    async fn summarize_events(&self, events: &[Event]) -> Result<Option<Event>> {
        // Custom summarization logic
        // Return None to skip compaction for this window
        todo!()
    }
}

Como a compactação afeta o histórico

Quando conversation_history() é chamado em uma sessão com eventos de compactação:

1. O evento de compactação mais recente é localizado
2. O resumo desse evento substitui todos os eventos até o limite de compactação
3. Somente os eventos posteriores ao limite são incluídos individualmente

Isso é transparente para os agentes — eles recebem um histórico de conversa coerente que inclui o resumo seguido pelos eventos recentes.

Linha do tempo de exemplo

Com compaction_interval: 3 e overlap_size: 1:

Após a invocação 6, o agente vê: [Summary B, event 6 overlap events, event 7+]

Observações

• A falha na compactação não é fatal — o executor registra um aviso e continua
• A compactação é executada após a conclusão do fluxo de invocações, não durante
• O evento de compactação é persistido no serviço de sessão para garantir durabilidade
• Use um modelo rápido e econômico para a sumarização (por exemplo, gemini-3.5-flash-lite)