What Google ADK already keeps
ADK sessions hold conversation state, and a memory service can store and search past sessions. A temporal store adds explicit supersession, as-of queries and identity-scoped visibility.
Where Auld fits
Register recall and remember as function tools on the agent. Keep session state for the conversation; use Auld for facts that must stay correct as they change and must be filtered by viewer.
| Concern | Google ADK | Auld |
|---|---|---|
| Current conversation | Yes | Not needed |
| Facts across sessions and channels | Your code | Yes |
| Which fact is current after a change | Your code | Yes, with history |
| What was true on a date | Your code | Yes (asOf) |
| Who may see a memory | Your code | Identities and audiences |
| Source for each statement | Your code | Returned with every memory |
Implementation sequence
Write function tools
ADK turns typed Python functions with docstrings into tools.
Read identity from context
Use the session’s user id rather than a model argument.
Attach to the agent
Add both tools in
tools=[...].Decide what to ingest
Ingest user-stated facts and business events, not every turn.
Example
import os, requests
AULD = os.environ["AULD_API_BASE"] # e.g. https://YOUR-AULD-HOST
HEADERS = {"Authorization": f"Bearer {os.environ['AULD_API_KEY']}"}
def auld_post(path: str, body: dict) -> dict:
r = requests.post(f"{AULD}/v1/{path}", json=body, headers=HEADERS, timeout=30)
r.raise_for_status()
return r.json()
def remember(text: str, user_id: str, source_id: str, occurred_at: str) -> str:
"""Store a dated record for one user. Returns the job id."""
return auld_post("records", {"sourceId": source_id, "text": text,
"occurredAt": occurred_at, "author": user_id,
"visibility": f"user:{user_id}"})["jobId"]
def recall(query: str, user_id: str, max_tokens: int = 2000) -> str:
"""Current memories with sources, formatted for a prompt."""
res = auld_post("recall", {"query": query, "viewer": user_id, "maxTokens": max_tokens})
return "\n".join(f"- {m['text']} ({m['sources'][0]['title']}, {m['sources'][0]['occurredAt'][:10]})"
for m in res["memories"]) or "No relevant memory."from google.adk.agents import Agent
from memory_client import recall, remember
def build_agent(user_id: str) -> Agent:
def recall_memory(query: str) -> str:
"""Look up the user's history: decisions, preferences, account facts."""
return recall(query, user_id)
def save_memory(fact: str, occurred_at: str) -> dict:
"""Save a fact the user stated. occurred_at is an ISO 8601 time."""
return {"jobId": remember(fact, user_id, f"adk-{user_id}-{occurred_at}", occurred_at)}
return Agent(name="assistant", model="gemini-2.0-flash",
instruction="Recall memory before answering about past interactions.",
tools=[recall_memory, save_memory])Illustrative example · standard HTTP · check the framework’s current docs for exact signatures
Or connect the MCP server
If your Google ADK setup can use MCP tools, point it at the Auld MCP endpoint instead of writing wrappers. The model gets remember, recall, forget and memory_status. Use wrappers when you need to inject the user id yourself or post-process results; use MCP for speed of setup.
Custom integration recipe using standard HTTP/MCP tools
- This recipe wires Google ADK’s own tool interface to the Auld REST API or MCP server; there is nothing Auld-specific to install.
- Bind the viewer id from your authentication layer, not from model output.
- Ingestion is asynchronous — poll the job before depending on a just-sent fact in tests.
- Recall returns up to your plan’s token limit (8,000 on Pay as you go and Flex).
Frequently asked questions
Do I still need ADK’s memory service?
Not for facts stored in Auld. You may keep it for searching raw past sessions.
Which model name should I use?
Any your ADK setup supports; the example name is illustrative.