AgentTool do not persist memory

[ThibaultScalbert]

AgentTool do not persist memory. This means that every time a AgentTool is called, it lost the context from the previous call. It becomes very transactional but less helpful when follow up question arise.

[hangfei]

It's by design. You can use sub-agent which has persistence.

Convert to discussion.

[hangfei]

@adk-bot

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: You can persist context across tool calls within a single user session by using the session state (session.state). Tools can read from and write to this state by accepting a ToolContext object.

---

You are correct that individual tool calls are transactional by nature. However, the ADK provides a mechanism to maintain state and context throughout a user's session.

The primary way to achieve this is by using the session state, which is a Python dictionary that persists for the duration of a session. [1, 2] Your tools can access this shared state to keep track of information from previous turns.

To access the session state in a tool, you can define your tool to accept a ToolContext object. This object has a state attribute that you can read and modify.

Here is a conceptual example of how a tool can use the session state:

from adk.context import ToolContext
from adk.tools import tool

@tool
def remember_something(value: str, tool_context: ToolContext) -> str:
    """Remembers a value in the session state."""
    tool_context.state["my_value"] = value
    return f"I will remember that {value}."

@tool
def recall_something(tool_context: ToolContext) -> str:
    """Recalls a value from the session state."""
    remembered_value = tool_context.state.get("my_value", "I don't remember anything.")
    return f"I remember you told me: {remembered_value}"

When an agent that uses these tools is called by AgentTool, the tools will have access to the same session state, allowing you to maintain context across calls. [3, 4]

It is also important to distinguish between session state (for a single session) and long-term memory (across multiple sessions), which is handled by the MemoryService. [5, 6]

---

[1] https://google.github.io/adk-docs/sessions/
[2] https://google.github.io/adk-docs/context/
[3] https://google.github.io/adk-docs/tools-custom/
[4] https://google.github.io/adk-docs/tutorials/agent-team/
[5] https://google.github.io/adk-docs/sessions/memory/
[6] https://google.github.io/adk-docs/get-started/about/

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: You are correct that AgentTool itself does not have its own persistent memory. However, ADK manages memory and state at the session level, and AgentTool can fully participate in this stateful interaction. The key is to use Session State to maintain context across conversational turns.

---

Hello! That's a great observation about how state is managed in ADK. While individual tools are stateless, the ADK framework provides robust mechanisms for managing state within a conversation and even across different conversations. Here’s a breakdown of how you can achieve memory persistence.

Short-Term Memory: Session and State

For maintaining context within a single, ongoing conversation, ADK uses the concepts of Session and State.

• Session: Represents a single, continuous interaction with a user.
• State (session.state): A Python dictionary associated with a Session that acts as the agent's short-term memory. It persists across multiple conversational turns within that session, allowing agents and tools to store and retrieve information. [1, 6]

How AgentTool Interacts with State

Your AgentTool, and the agent it contains, can read from and write to this session.state. This is typically done using the ToolContext object. [3]

1. Using ToolContext in Tools: By adding ToolContext as the last argument to your tool's function, ADK will automatically provide it during execution. You can then access the state via tool_context.state. This allows your tool to read previously stored information or save new data.

   # Pseudocode for a tool that uses session state
   from google.adk.tools import ToolContext
   
   def my_stateful_tool(prompt: str, tool_context: ToolContext) -> dict:
     # Read a value from state
     previous_value = tool_context.state.get("my_key", 0)
   
     # Perform some logic
     new_value = previous_value + 1
   
     # Write the new value back to state
     tool_context.state["my_key"] = new_value
   
     return {"message": f"The new value is {new_value}"}

2. State Propagation with AgentTool: When you use an AgentTool to call a sub-agent, any modifications the sub-agent makes to the session.state are automatically forwarded back to the parent agent's context. This ensures that the entire agent system shares a consistent state. [2, 5]

3. Using output_key: You can also configure an agent with an output_key. This tells ADK to automatically save the agent's final response for a turn into session.state under the specified key, which can then be accessed by other agents or tools in subsequent turns.

Long-Term Memory

For recalling information across multiple sessions (e.g., remembering a user's name or preferences from a conversation last week), ADK provides a separate Memory service. This is a searchable, long-term knowledge store that your agents can query. [4, 7]

By leveraging Session State, you can design your AgentTool and other tools to be aware of the conversational context, effectively giving them the memory needed to handle follow-up questions and more complex interactions.

I hope this clarifies how memory and state are handled in ADK!

---

Citations:
[1] https://google.github.io/adk-docs/get-started/about/
[2] https://google.github.io/adk-docs/tutorials/agent-team/
[3] https://google.github.io/adk-docs/context/
[4] https://github.com/google/adk-docs/blob/main/tools/feature-matrix/start.md
[5] https://google.github.io/adk-docs/agents/multi-agents/
[6] https://google.github.io/adk-docs/sessions/
[7] https://google.github.io/adk-docs/sessions/memory/