Guides / Use cases

Personal assistants and companions

For personal assistants, AI companions and any chat product the same person keeps coming back to. With Recall your assistant starts every conversation knowing the user's plans, preferences and the people in their life, without old transcripts in the prompt: one call per message stores what was said and returns the memory for the reply.

What memory adds

Without memory, every conversation starts from zero and the user repeats themselves. With it, the assistant picks up where they left off:

Recall does not write the replies. Your model does, as it does now; Recall gives it what it should know about this user, and learns from what they say.

How to model it

Ask about one user through their peer (user.chat). The workspace-level recall.chat reads every user's memory, which is never what you want in a personal assistant.

Build it

Install the SDK (npm install @recall-memory/sdk or pip install recall-mem) and set RECALL_API_KEY. Create handles for the user, the assistant and the conversation.

import { Recall } from "@recall-memory/sdk";

const recall = new Recall({ workspaceId: "assistant-prod" });

// The user is a peer, keyed by your own stable user id (not their email address).
const user = recall.peer("user-8412", { metadata: { locale: "nl-NL" } });
// You write the assistant's persona, so Recall should not learn from its replies.
const assistant = recall.peer("assistant", { configuration: { observeMe: false } });
// One session per conversation. Memory of the user is shared across all of them.
const chat = recall.session("chat-20261010-a91f");

from recall_memory import PeerConfig, Recall

recall = Recall(workspace_id="assistant-prod")

# The user is a peer, keyed by your own stable user id (not their email address).
user = recall.peer("user-8412", metadata={"locale": "nl-NL"})
# You write the assistant's persona, so Recall should not learn from its replies.
assistant = recall.peer("assistant", configuration=PeerConfig(observe_me=False))
# One session per conversation. Memory of the user is shared across all of them.
chat = recall.session("chat-20261010-a91f")

Settings are facts. When a user fills in their profile ("I'm vegetarian", "keep it short"), write it down as conclusions about them. They are stored as given, can be found at once and show up in every answer that needs them. What the user says in conversation is learned in the background instead.

// What the user entered in your app's settings is fact, not inference: store it as such.
// It is searchable at once, without waiting for background learning.
await user.conclusions.create(["Is vegetarian.", "Prefers short answers."]);

# What the user entered in your app's settings is fact, not inference: store it as such.
# It is searchable at once, without waiting for background learning.
user.conclusions.create([{"content": "Is vegetarian."}, {"content": "Prefers short answers."}])

The peer card: facts for every prompt. The card is a short list of the most stable facts about the user. Recall writes and updates it as it learns, and turn returns it with the context, so your model always sees it. You can add lines yourself, for example from onboarding. setCard replaces the whole list, so read it first.

// The peer card: a short list of facts for every prompt. Recall writes and updates it as it
// learns; you can add lines yourself, e.g. from onboarding. setCard replaces the whole card.
const card = (await user.getCard()) ?? [];
await user.setCard([
  ...card,
  "Prefers to be called Sam.",
  "Vegetarian.",
  "Timezone Europe/Amsterdam.",
]);

# The peer card: a short list of facts for every prompt. Recall writes and updates it as it
# learns; you can add lines yourself, e.g. from onboarding. set_card replaces the whole card.
card = user.get_card() or []
user.set_card([*card, "Prefers to be called Sam.", "Vegetarian.", "Timezone Europe/Amsterdam."])

Every message: one request. turn stores the user's message and returns the context for your model in the same round trip: the conversation so far, a summary of older turns, the card and what Recall has learned about the user, trimmed to tokens. Building the context uses no model, so it is fast and included in the price; you pay only for learning from the message. Store the reply afterwards so the conversation is complete.

// Every user message: one request stores it and returns the context for the reply: this
// conversation so far, a summary of older turns, the card and what Recall knows about Sam.
const { context } = await chat.turn(
  [user.message("My parents visit on Saturday. Can you plan a dinner for four?")],
  { peerTarget: user, tokens: 3000 },
);
const messages = context.toOpenAI(assistant); // or context.toAnthropicParams(assistant)
// Your model writes the reply from `messages`; store it so the conversation is complete.
const reply = "How about a mushroom risotto with a big salad? Here is a shopping list.";
await chat.addMessages([assistant.message(reply)]);

# Every user message: one request stores it and returns the context for the reply: this
# conversation so far, a summary of older turns, the card and what Recall knows about Sam.
result = chat.turn(
    [user.message("My parents visit on Saturday. Can you plan a dinner for four?")],
    peer_target=user,
    tokens=3000,
)
messages = result.context.to_openai(assistant=assistant)  # or .to_anthropic_params(...)
# Your model writes the reply from `messages`; store it so the conversation is complete.
reply = "How about a mushroom risotto with a big salad? Here is a shopping list."
chat.add_messages([assistant.message(reply)])

Questions about the user: ask. For things outside the chat, such as a morning briefing, a reminder or a suggestion for the weekend, ask the user's memory in plain language. That is one model call of a few seconds, so run it in the background, not while the user waits for a reply.

// A question about the user, for a reminder or a suggestion outside the chat. One model call
// of a few seconds. (waitForIdle is for this demo; real apps rarely block on learning.)
await recall.waitForIdle();
const answer = await user.chat("What should I keep in mind when suggesting a weekend plan?", {
  reasoningLevel: "low",
});

# A question about the user, for a reminder or a suggestion outside the chat. One model call
# of a few seconds. (wait_for_idle is for this demo; real apps rarely block on learning.)
recall.wait_for_idle()
answer = user.chat(
    "What should I keep in mind when suggesting a weekend plan?", reasoning_level="low"
)

Let users fix what you remember. A "What I remember" page builds trust and catches mistakes. List the user's facts, delete the ones they flag, and store the right value when they give it. Deleting a fact does not change the card, so update the card too. When the user corrects something in conversation ("I moved to Amersfoort"), you need not do anything: Recall closes the old fact itself.

// A "What I remember" page: list the facts and let the user delete a wrong or outdated one.
// Deleting a fact does not edit the card, so remove it there too, and store the new value.
const { items: facts } = await user.conclusions.list({ size: 50 });
const flagged = facts.find((f) => f.content.toLowerCase().includes("vegetarian")); // user's pick
if (flagged) await user.conclusions.delete(flagged.id);
const current = (await user.getCard()) ?? [];
await user.setCard(current.filter((line) => !line.toLowerCase().includes("vegetarian")));
await user.conclusions.create("Eats fish, but no meat.");

# A "What I remember" page: list the facts and let the user delete a wrong or outdated one.
# Deleting a fact does not edit the card, so remove it there too, and store the new value.
facts = user.conclusions.list(size=50).items
flagged = next((f for f in facts if "vegetarian" in f.content.lower()), None)
if flagged:  # the one the user flagged
    user.conclusions.delete(flagged.id)
current = user.get_card() or []
user.set_card([line for line in current if "vegetarian" not in line.lower()])
user.conclusions.create([{"content": "Eats fish, but no meat."}])

Account deletion. user.delete() erases the user: their messages, everything learned about them and their card. The assistant's replies are another peer's messages, so delete the user's conversations as well.

// The user deletes their account: erase them (their messages, every fact and the card), then
// their conversations, which still hold the assistant's replies to them.
const chats = await (await user.sessions()).toArray();
await user.delete();
for (const c of chats) await c.delete();

# The user deletes their account: erase them (their messages, every fact and the card), then
# their conversations, which still hold the assistant's replies to them.
chats = list(user.sessions())
user.delete()
for c in chats:
    c.delete()

Memory in Claude and ChatGPT

To give Claude or ChatGPT memory across chats you build nothing: add Recall as a connector with the URL https://api.recallmem.dev/mcp and sign in. With Remember automatically ticked (the default) the app saves lasting facts you share, such as preferences, plans and people, without being asked; untick it per app under API keys → Connected apps to have it save only what you ask. The steps for each app are in Add Recall as a connector. That is memory for your own Recall account. To give your product's users memory, build it as above.

Settings that matter

Cost and speed

Measured from Europe against the hosted API (Frankfurt), October 2026: a turn or context call took 0.3 to 0.7 seconds, a search about 0.9 seconds, a question at minimal or low 2 to 4.5 seconds. Learning happens in the background, usually within about 20 seconds of a message, and never holds up a call.

Context, search, storage, summaries and dreams are included. You pay for learning, $1.75 per million message tokens with every message counting as at least 50, and for questions. A user who sends 300 messages a month of about 40 tokens, gets 300 replies of about 150 tokens, and about whom your app asks 30 questions at low:

An answer from empty memory is free. Set a monthly cap and auto top-up under Billing. More in Cost and speed.

Privacy and forgetting

People tell assistants a lot: health, relationships, money, other people. Say in your privacy notice that conversations are stored to give the assistant memory, that AI model providers process them, and how users delete it. Give users a page that shows what is remembered, like the one above.

• Keep out what memory does not need: passwords, card numbers, one-time codes and ID numbers. Strip them before a message reaches Recall. A private or incognito mode should not send messages at all.
• Forgetting a user: user.delete() (or DELETE /v3/workspaces/{workspace}/peers/{peer}) erases their messages, every fact and card about them or from their view, the summaries that quoted them (rebuilt without them) and cached answers. Delete their conversations too, for the assistant's replies. See Forget a person.
• Where data lives: the database and API are in Frankfurt (EU). Text is processed by AI model providers in the US through OpenRouter, restricted to providers that do not collect the data, and customer data is not used to train models. See the privacy policy, the DPA and security.

Companions. Memory makes a companion feel like it knows the person, which is the point and also the risk. Keep it honest: let the character say it is an AI when asked, and do not use what it remembers to make people feel guilty for leaving or to keep them chatting longer. Let people see and delete what it remembers. If someone writes about self-harm or a crisis, your app has to point them to real help; Recall stores what was said, it does not notice or handle it. If minors may use your app, read Privacy, consent and forgetting first.

Pitfalls

• Learning from your own assistant. Without observeMe: false, Recall also learns from the assistant's replies and builds a memory of your own persona, which you pay for and do not need.
• An email address as the peer id. Email addresses change and are personal data in every log line. Use your internal user id.
• Asking on every message. A question takes seconds. Reply from the context turn returns; ask only for things outside the chat, ahead of time.
• Asking the workspace about one user. recall.chat reads every user. Ask through the user's peer.
• One session forever. The summary then mixes every topic. Start a session per conversation; what Recall knows about the user carries over anyway.
• Expecting Recall to write the reply. Recall is memory, not the reply model. Bring your own model and persona prompt.

Next: Designing workspaces, peers and sessions · Privacy, consent and forgetting