What Microsoft Agent Framework already keeps

Agents keep conversation threads, and context providers can inject information before each run. Durable facts and their history come from whatever provider you plug in.

Where Auld fits

Use function tools for explicit recall and remember, or implement a context provider that calls recall before each invocation. The provider pattern keeps prompts consistent across agents in a workflow.

ConcernMicrosoft Agent FrameworkAuld
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. Start with function tools

    Typed functions passed as the agent’s tools.

  2. Move to a context provider

    When every turn needs memory, call recall in the provider hook.

  3. Map identities

    Use your directory’s user id as the Auld viewer.

  4. Mirror in .NET

    The same two HTTP calls work with HttpClient.

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."
Microsoft Agent Framework wiring
# Illustrative wiring: function tools are typed callables passed to the agent.
from typing import Annotated
from memory_client import recall

def make_tools(user_id: str):
    def recall_memory(query: Annotated[str, "What to look up"]) -> str:
        """Recall durable facts about the signed-in user."""
        return recall(query, user_id)
    return [recall_memory]

# agent = chat_client.create_agent(name="helper",
#     instructions="Recall memory before answering history questions.",
#     tools=make_tools(user.id))

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

Or connect the MCP server

If your Microsoft Agent Framework 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 Microsoft Agent Framework’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

Is there a .NET example?

The calls are plain HTTPS POSTs; any .NET HTTP client works. See the API reference for request bodies.

Threads or Auld?

Threads for the running conversation, Auld for facts across conversations and channels.