Memory for Agno

What Agno already keeps

Agno can persist sessions and user memories in a database you configure. Those are useful for personalization within your app; they don’t model supersession with dated sources across systems.

Where Auld fits

Add Auld as tools on the agent and send records from the systems around it — CRM updates, tickets, emails — not just chat turns. The agent then recalls facts it never saw in conversation.

Implementation sequence

1. 01

   Define two tool functions

   Plain Python functions with docstrings.

2. 02

   Attach to the agent

   Pass them in tools=[...].

3. 03

   Feed other systems

   Ingest business events directly from your backend.

4. 04

   Choose MCP if preferred

   Agno can also connect to MCP servers; point it at the Auld MCP endpoint instead of writing tools.

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 agno.agent import Agent
from memory_client import recall

def agent_for(user_id: str, model) -> Agent:
    def recall_memory(question: str) -> str:
        """Current facts about this user's account, with dates and sources."""
        return recall(question, user_id)

    return Agent(model=model, tools=[recall_memory],
                 instructions=["Call recall_memory before answering about the user's history."])

Illustrative example · standard HTTP · check the framework’s current docs for exact signatures

Or connect the MCP server

If your Agno 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.

Connect an MCP client →

Custom integration recipe using standard HTTP/MCP tools

• This recipe wires Agno’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