Google ADK + Memanto: persistent long-term memory for ADK agents

A Google ADK agent forgets everything when its session ends. ADK's built-in InMemoryMemoryService is lost on restart, and Vertex AI Memory Bank ties you to Google Cloud.

memanto-google-adk is a drop-in ADK memory service backed by Memanto:

Everything lives in a Memanto agent, so you can read, edit and audit what your ADK agent knows with the Memanto CLI or web UI.

Install

pip install memanto-google-adk
export MOORCHEH_API_KEY=...   # Memanto / Moorcheh key

Use it

import logging

from google.adk.agents import LlmAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.tools import preload_memory
from memanto_google_adk import MemantoMemoryService, remember_tool


async def save_to_memory(callback_context):
    # Store what is new in this session after every agent turn. If Memanto is
    # unreachable, log it rather than fail the user's turn: the next
    # successful save picks up the turns this one missed.
    try:
        await callback_context.add_session_to_memory()
    except Exception:
        logging.exception("Saving to Memanto failed")


agent = LlmAgent(
    name="travel_agent",
    model="gemini-2.5-flash",
    instruction="You are a travel assistant.",
    tools=[preload_memory, remember_tool],
    after_agent_callback=save_to_memory,
)

runner = Runner(
    app_name="travel",
    agent=agent,
    session_service=InMemorySessionService(),
    memory_service=MemantoMemoryService(),
)

• preload_memory recalls memories that match the user's message and adds them to every request. Use load_memory instead if the model should decide when to look things up.
• remember_tool is optional: memories are extracted from the saved session anyway, but the tool lets the agent save a fact the moment it hears it.
• after_agent_callback is where saving happens. Each call extracts only the events added since the last save, so calling it every turn does not store anything twice. Extraction is one LLM call per save; to keep it off the response path, you can run it as a background task instead.

With adk web / adk run

Register the memanto:// scheme in a services.py:

from google.adk.cli.service_registry import get_service_registry
from memanto_google_adk import MemantoMemoryService

get_service_registry().register_memory_service("memanto", MemantoMemoryService.from_uri)

Where ADK looks for it depends on the command:

A services.py in the wrong folder fails at startup with Unsupported memory service URI: memanto:. Set MOORCHEH_API_KEY in the environment before starting.

memanto://my-agent uses the Memanto agent my-agent for every app, instead of one per app.

How memory is scoped

• One Memanto agent per ADK app, named adk-<app_name> (Memanto agent IDs allow only letters, digits, - and _). Pass agent_id= to share one Memanto agent across several apps.
• Each ADK user's memories are private. Every memory is tagged user-<sha256 of user_id>, and recall filters by that tag. The service takes the user from ADK's session, never from the model, and checks every result against the tag again before returning it, so one user never sees another's memories.
• Sessions are saved incrementally. Stored memories carry a marker for the last event they covered. The next save extracts only later events, even from a different process, and a retried save stores nothing.

API

Limits

• One active session per Memanto agent. Activating an agent signs out every other client of that agent. Several processes serving the same app will take turns re-activating (the service retries once on a session error), which works but adds latency. For multi-worker deployments, prefer one worker per agent.
• Tool calls and tool results are not extracted, only user and agent text.