Memory

With memory on, the agent remembers what it learned about a customer — a preference, an open complaint, what it promised to do — and starts their next conversation knowing it, on the phone or in your app. It learns quietly in the background and never slows a reply.

Who is remembered

How it works

• Recall happens once, when the conversation starts, for every kind of agent — flow agents included, where it reaches every step. It is allowed 1.5 seconds; if it takes longer, the conversation goes ahead without memory rather than keep the customer waiting.
• Learning runs in the background, every four customer turns and once more at the end. Text is redacted before it is stored — card numbers, Aadhaar and PAN, phone numbers and email addresses — with the same redaction transcripts get. A summary at the end is stored only when it holds something worth keeping.
• Nothing in it can break a conversation. A memory that cannot be recalled or stored is logged and counted; the conversation carries on.

Conversations continue

Memory keeps facts; this keeps the conversation itself. A customer who comes back — later that day, next week, on another of their devices — finds their chat where they left it, the way a messaging app keeps a thread, and the agent picks up from it.

When they come back:

• In the chat, the window opens on the conversation: the earlier messages, a voice call as one row, a date line where the day changes. There is no second welcome message — the agent continues, and the customer types next.
• On a call, the agent greets them as on any new call, and knows the latest 20 messages, so it carries on rather than starting over. Its memories are recalled as usual.
• If the earlier messages cannot be read in time, the conversation starts fresh rather than keep the customer waiting.

Forgetting the customer — forgetMemory() in your app, Forget this person in the dashboard — deletes these messages with the memories. From your app, a forgetMemory() that succeeds also clears the chat on screen; one that fails deletes nothing and leaves the chat as it is. Turning memory off for them (setMemory(false)) stops keeping and showing them, and deletes nothing, as with memories.

On an SDK before 0.7.0 the chat window does not show the earlier messages; the agent still continues from them. The chat window's side: Chat → Coming back to a conversation.

Turn it on

Agent → Memory → Settings — the same section as Embed & Widgets → Users & memory.

The agent's website and in-app conversations, and its A/B test variants, share its memory: a customer is one customer to the agent, whichever answered.

Saving these settings is a change to the agent like any other: on a live agent, in a workspace that reviews changes, it goes for approval.

Each customer's choice

A customer can turn memory off for themselves. Pass it with identify(), or on its own with setMemory(); the SDK remembers the choice for that customer on that install, so you need not repeat it at every launch. It applies from the next conversation.

const client = useGraineClient();
client.identify({ user_id: user.id, name: user.firstName }, { memory: user.allowsMemory });
// later, from your privacy settings screen
client.setMemory(false);

With memory off, that customer's conversations are neither recalled nor stored. It defaults to on.

Show a customer what is remembered

memories() returns what the agent remembers about the signed-in customer, for this agent's memory scope: newest first, at most 100, each already redacted. Show it on a privacy screen beside the switch that turns memory off and the button that forgets.

const memories = await client.memories();
// [{ id, text, createdAt, updatedAt }] — createdAt and updatedAt are Dates, or null

Like forgetting, it answers only on one of the customer's own devices — another is refused with device_limit — and needs an identifier (identity_required). Every return type and error: Identity and memory, and the fields of GraineMemory.

Forgetting

From your app, forgetMemory() deletes everything remembered about the signed-in customer, for this agent's memory scope — and the conversation kept so it can continue — and resolves with how many memories it deleted (0 when there were none). It works only from one of the customer's own devices; another device is refused with device_limit, and one with no identifier with identity_required.

The chat on screen clears only when it succeeds. The conversation is part of what was forgotten, so a successful forgetMemory() empties the chat window too. A failure — Graine unavailable (unavailable, 503), device_limit, no network — deletes nothing, and the chat stays as it is.

await client.forgetMemory();

From the dashboard, under Agent → Memory → People: everyone the agent has talked to while they were identified, each shown by their identifier — User ID · u_8812, Email · asha@acme.example — as in Call History.

A person's panel also lists their recent conversations in Call History.

The activity log records that an agent's memory was forgotten, and by whom — never whose memory it was.

What is stored

Short facts, each with the agent, the channel and the conversation it came from, under the customer's one-way key. Graine stores the identifier your app sends so your team can see who each conversation was with; the memory service only ever receives a one-way key derived from it (What Graine keeps). Memories expire after the retention you set.

For a customer whose conversation continues, their last 50 messages with each agent are kept as they were said, for 7 days after the latest (Conversations continue).

Memory is personal data. Tell your customers the agent remembers them, use What to remember — and what never to to keep anything sensitive out, and give them the way to turn it off and to be forgotten.

Limits

Troubleshooting

Where next