ag2-memorysync

MemorySync for AG2 (the classic AutoGen ConversableAgent framework, pip install autogen): an automatic memory loop — recall injected before every reply, the user's turns captured for fact extraction, zero extra code per turn.

pip install ag2-memorysync

Quick start

from autogen import ConversableAgent
from ag2_memorysync import MemorySyncCapability

assistant = ConversableAgent("assistant", llm_config=...)

memory = MemorySyncCapability(
    api_key="ms_...",              # or MEMORYSYNC_API_KEY
    user_id="customer-42",         # required — who these memories belong to
    session_id="support-chat",     # tags the facts from this chat
)
memory.add_to_agent(assistant)     # that's the whole integration

From then on every incoming user message is enriched with recalled context and sent to MemorySync, which extracts the durable facts it contains — through AG2's own hook system (process_last_received_message

• process_message_before_send). The agent's own replies are not sent: assistant replies are not stored as memories.

Why this one

Semantics worth knowing

• The reply is never stalled and never broken. Recall blocks at most recall_timeout (default 1.2s); sending a turn is fire-and-forget off the hot path. Outages and quota exhaustion degrade to "no memories this turn".
• User turns are sent to fact extraction; only durable facts are stored. Each user turn goes to MemorySync as plain text with role: "user" under the ag2::<session> session scope. The server extracts the durable facts it contains and stores only those, tagged with session_id: "ag2::<session>"; filler such as "ok" or "thanks" yields none, and the turn text itself is not stored. Deterministic idempotency seeds let the server recognise a retry of the same turn and not extract it twice.
• Roles follow the speaker, not the hook. A message sent by an agent that speaks for a person — a UserProxyAgent, an agent whose human_input_mode is "ALWAYS", or a "TERMINATE"-mode agent with no model — is the user's turn, even when the capability is attached to that agent too. Every other agent's outgoing message is an assistant reply and is not sent. That includes a plain ConversableAgent(..., llm_config=...): its default human_input_mode="TERMINATE" only asks a person when the chat ends, so its messages come from the model.
• Attach it to both sides if you like. A process-wide registry records what each attached agent just handled, so the person's words are sent once — not again by the receiving side — and an assistant's reply arriving at the person's proxy is never sent as theirs.
• Tool/function messages are never sent.
• register_memory_tools(memory, caller=..., executor=...) adds search_memory + save_memory tools (the caller needs an llm_config, as usual for AG2 tools).
• memory.flush() waits for in-flight sends (shutdown/tests); memory.close() flushes and releases the HTTP client.

Configuration

Development

pip install -e . "autogen[openai]" pytest "httpx>=0.25,<1"
python -m pytest tests -q      # 31 tests through REAL ConversableAgent chats

The suite includes a reproduction of zep-ag2's documented multi-agent double-store scenario (each utterance handled once), a UserProxyAgent + assistant chat with the capability on both sides (the person's words are sent once; the assistant's replies are not sent), and a chat driven from inside asyncio.run() (no deadlock).

License

MIT