Deterministic memories
Copy as MarkdownIn the previous post we sent the agent’s session events to Memory Bank with add_events_to_memory() in an after-agent callback. An LLM extracts useful facts from those events, and embeddings make the saved facts searchable in a later session. That gives us general recall, but the model may leave out the specific orders from a trading run.
For this agent, I want to keep the orders and the reasons for placing them. We already have that data in the trade tool, so let’s use it to write a memory ourselves. We can keep the automatic extraction alongside it for preferences and other useful context.
There are two pieces to saving a memory deterministically.
First, capture what happened — in a structured way, at the moment it happens. The trade is a tool call, so place_trade_order is the natural place to record it: after submit_order() returns, we stash the submitted order in the tool context’s session state.
# Record the confirmed fill in session state so save_to_memory can
# persist a clean, structured trade record at the end of the cycle.
if tool_context is not None:
trades = tool_context.state.get("trades_this_session", [])
trades.append({
"symbol": symbol,
"side": side,
"amount_usd": amount_usd,
"qty": qty,
"reason": reason,
})
tool_context.state["trades_this_session"] = trades
Note: The example’s “confirmed fill” comment and “Trades executed” heading describe more than the code checks. It records an order submission, without waiting for the order to fill. If you want a record of actual fills, check Alpaca’s order status or consume its trade updates before recording them.
Second, in the after-agent callback, send the events for LLM extraction and write our own memory for the orders. We format the captured orders and their reasons into one MemoryEntry, then save it with add_memory(). The default explicit-memory path creates the supplied fact without LLM extraction. Embeddings still support retrieval; what’s deterministic here is our choice of the memory’s contents. A write can still fail, and a successful write doesn’t guarantee that a later query will retrieve it.
async def save_to_memory(callback_context: CallbackContext):
# Full transcript: general cross-session recall (news context, reasoning).
await callback_context.add_events_to_memory(
events=callback_context.session.events,
custom_metadata={"force_flush": True},
)
# Structured trade record: a clean, guaranteed memory of exactly what was
# traded and why, built from the orders captured in place_trade_order.
trades = callback_context.state.get("trades_this_session", [])
if not trades:
return
lines = []
for t in trades:
size = f"${t['amount_usd']}" if t.get("amount_usd") else f"{t['qty']} shares"
rationale = f" — {t['reason']}" if t.get("reason") else ""
lines.append(f"{t['side'].upper()} {t['symbol']} {size}{rationale}")
text = "Trades executed this session:\n" + "\n".join(lines)
print(text, flush=True)
await callback_context.add_memory(
memories=[MemoryEntry(
content=types.Content(role="model", parts=[types.Part(text=text)]),
author="TradingAgent",
timestamp=datetime.now(timezone.utc).isoformat(),
)],
# Set a TTL of ~1 month (30 days) so the trading history can be recalled
# for a month while avoiding too much clutter.
custom_metadata={"type": "trade", "force_flush": True, "ttl": "2592000s"},
)
The add_events_to_memory() call is unchanged from the previous post, including force_flush. The new pieces are the explicit memory write and a reason argument on place_trade_order. The agent’s instructions ask it to include the ticker, sentiment score, and a one-line news summary in that reason. We save the supplied rationale with the order so a later session has some context for why it was placed.
The explicit memory carries a ttl of "2592000s", or 30 days. That limits how long this copy of the order history stays in Memory Bank. The TTL is supplied only on add_memory() here; it doesn’t change the retention of facts extracted from the session events, which may also mention an order. Tune the window for your application. The durable order history still lives in Alpaca.
Note: This example writes one memory containing all orders in trades_this_session each time the callback reaches add_memory(). It doesn’t clear that list after saving, so later turns in the same session can write the same orders again, with a new expiry. For repeated runs in one session, track which orders have been saved and only write new ones; retries also need a way to avoid duplicate records.
The full diff to add this is as follows.
After a successful save, Memory Bank has the explicit order record alongside any facts extracted from the session events. Start a fresh session and ask “what orders did you recently submit?” to try retrieving it. The memory tools and similarity search work the same way as before; this time, we chose the order details to send to the memory store ourselves.