Context Management Strategies (Windowing/Summarization) in ADK Session Lifecycle

[yantology]

Hello ADK Development Team and Community,

I've been reviewing the session lifecycle documentation at https://google.github.io/adk-docs/sessions/session/. The documentation clearly explains how a session is started, context is provided to the agent, the agent processes the query, and interactions are saved.

However, I couldn't find an explicit mention of built-in mechanisms for advanced context management techniques such as sliding windows (using the last N conversation turns) or summarization (summarizing previous conversation history) to handle long conversations and potential token limits when interacting with language models (LLMs).

Regarding point "3. Agent Processing: The agent analyzes the user's query and potentially the session state and event history to determine the response," does this imply that the implementation of strategies like windowing or summarization is entirely the responsibility of the user-developed agent's logic?

If so:

Does the agent have access to the complete event history within the session to be able to manually apply this windowing/summarization logic before sending the context to an LLM?
Are there any best practices or recommended examples within the ADK ecosystem for managing long conversation contexts efficiently without necessarily creating a new session for every few turns (which would break the natural conversational flow)?

I'm asking because, without context management strategies, sending the entire conversation history for each turn can quickly become inefficient and costly, especially with models that have strict input token limits. On the other hand, if each conversation or turn effectively creates a new "memory" (session), this would also eliminate continuity.

Could you please provide some clarity on how ADK is designed to handle these scenarios of long, ongoing conversations with respect to context management?

Thank you!

[calvingiles]

Disclaimer: not an ADK maintainer.

We have been exploring building human-in-the-loop approval mechanisms #640, and a core part of that involved how the set of Events is re-written to include only the relevant messages. Most of this is handled by native ADK in the contents processor as part of the single flow.

One way to support a flexible context window management would be to provide another processor in the single flow that filters or aggregates the events before they are processed into the content.

Alternatively, if you wish to take the already processed contents and further processed, you could simple do this in the before_model_callback. If you want this on all sub agents you would need to register this on every sub agent.

Simple truncating the history should involve overwriting the llm_request.content. If you wish to create summaries that are sticky over time you will need to capture those summaries in the state so you can reliably recall them in future invocations.

Is this what you were thinking of? I can make a simple callback to demo this if helpful.

[calvingiles]

I threw #891 together - let me know if it helps

[yantology]

oke,thanks for your information,it very helpfull

[growmuye]

I use LangChain.... I did some processing at the bottom, those interested can refer to it:

import json
import logging
from typing import Iterable, AsyncGenerator

from google.adk.models import LlmRequest, LlmResponse
from google.adk.models.lite_llm import LiteLlm
from google.adk.models.lite_llm import (
    _get_completion_inputs as get_original_completion_inputs,
)
from google.genai import types
from langchain_core.messages import trim_messages
from langchain_core.messages.utils import (
    count_tokens_approximately,
    convert_to_openai_messages,
)
from langchain_openai.chat_models.base import _convert_dict_to_message
from litellm.types.utils import Message
from litellm import ChatCompletionAssistantMessage
from litellm import ChatCompletionMessageToolCall
from litellm import Function
import google.adk.models.lite_llm

def get_and_compress_completion_inputs(
    llm_request: LlmRequest,
) -> tuple[Iterable[Message], Iterable[dict]]:
    openai_messages, tools, response_format = get_original_completion_inputs(
        llm_request
    )
    try:
        langchain_messages = []
        for m in openai_messages:
            langchain_messages.append(_convert_dict_to_message(m))

        new_langchain_messages = trim_messages(
            langchain_messages,
            strategy="last",
            token_counter=count_tokens_approximately,
            max_tokens=60 * 1024,
            include_system=True,
            start_on="human",
            end_on=("human", "tool"),
        )

        new_openai_messages = convert_to_openai_messages(new_langchain_messages)

    except Exception as e:
        error_log.exception(f"compress-异常:{e}")
        new_openai_messages = openai_messages
    return new_openai_messages, tools, response_format

google.adk.models.lite_llm._get_completion_inputs = get_and_compress_completion_inputs

[growmuye]

In terms of details, LangChain does a very good job. I hope ADK can consider more integration with LangChain.