What Haystack already keeps

Pipelines retrieve from document stores, and chat agents keep message lists. A document store returns what matches, not what is current.

Where Auld fits

Define recall as a Haystack Tool for agents, or as a custom component placed before the prompt builder in a fixed pipeline.

ConcernHaystackAuld
Current conversationYesNot needed
Facts across sessions and channelsYour codeYes
Which fact is current after a changeYour codeYes, with history
What was true on a dateYour codeYes (asOf)
Who may see a memoryYour codeIdentities and audiences
Source for each statementYour codeReturned with every memory

Implementation sequence

  1. Create a Tool

    Name, description, JSON schema parameters and the function.

  2. Give it to the Agent component

    Alongside your retrieval tools.

  3. Or add a component

    A custom component with a run method that outputs memories.

  4. Keep ids out of the schema

    Bind the user id when constructing the tool.

Example

memory_client.py — shared helper
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."
Haystack wiring
from haystack.tools import Tool
from memory_client import recall

def memory_tool(user_id: str) -> Tool:
    return Tool(
        name="recall_memory",
        description="Current facts and history about the user, with sources and dates.",
        parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
        function=lambda query: recall(query, user_id),
    )

# agent = Agent(chat_generator=generator, tools=[memory_tool(user.id), docs_search_tool])

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

Or connect the MCP server

If your Haystack 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 Haystack’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

Can Auld be a document store?

It isn’t designed as one. Keep static corpora in your document store and use Auld for evolving facts.

Tool or component?

Component when every request needs context; tool when the agent decides.