Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.liveavatar.com/llms.txt

Use this file to discover all available pages before exploring further.

Memory lets you carry over previous conversations into new ones. Without it, every session starts from a blank slate — the avatar has no idea it has spoken with this person before. Memory is the layer that connects sessions so the avatar can pick up where it left off.
Memory is used in FULL Mode only. In LITE Mode, you bring your own AI stack, so conversation history and recall are managed on your side.

​
Why memory exists

By default, sessions are isolated. Each one runs independently, knows nothing about the sessions before it, and forgets everything when it ends. That works for one-off interactions, but it breaks down the moment a conversation is meant to continue over time:
  • A coaching or therapy avatar that should recall what was discussed last week.
  • A tutor that remembers which lesson a student is on and what they struggled with.
  • A support agent that knows the customer’s history instead of asking them to repeat it.
Memory closes that gap. It captures the key information from past sessions and adds it to the context of your current one.

​
How memory works

Memory follows a simple lifecycle across the life of a session:
1

Session transcripts are recorded

As part of FULL Mode, both user and avatar responses are recorded throughout the session.
2

Memory is created

Using the recorded transcript, the key takeaways from the conversation are distilled into a memory. There are two ways to create one:
  • Bootstrapped from a prior session — pass prev_session_id when creating a session token. If that session has no memory yet, one is created from its transcript as the new session starts. The prior session must be a completed FULL Mode session with a transcript — bootstrapping from an empty or silent session returns an error.
  • Created directly — call POST /v1/memory with a session_id ahead of time, then attach it to a later session with session_memory_id.
Bootstrapping creates the memory on the spot, so the first session that triggers it sees added latency at startup while the transcript is distilled. Creating the memory ahead of time with POST /v1/memory avoids this.
3

Injected at the start of the next session

When a new session starts, the memory is injected as additional context.
4

Updated with each new session

When a session tied to a memory ends, that session’s transcript is folded back into the memory automatically. It grows richer with each successive conversation, with no extra calls on your part.
Once a memory exists, starting a session with it doesn’t slow things down — the avatar reads the prepared summary instead of re-processing past conversations.

​
Linking sessions together

Memory is opt-in. A standalone session never creates or uses memory, so existing integrations are unaffected. To give sessions continuity, you link them to a shared memory when creating a session token. The first linked session establishes the memory; each session after that adds to it and reads the accumulated summary. Conceptually, a memory is an ongoing thread, and the sessions tied to it are the conversations that make up that thread.
Memory is scoped to the sessions you explicitly link, not inferred automatically. You decide which conversations belong to the same thread.

​
How to use it

Memory is driven by two API surfaces:
  • Create a session token — pass a memory object with prev_session_id or session_memory_id to seed or attach memory for the session.
  • Memory endpoints — create, list, fetch, and delete memories directly.

​
What memory is not

Memory in its current form is intentionally focused:
  • It injects a single rolled-up summary, not a searchable archive of every past detail.
  • It is readable, so you can inspect what an avatar remembers and surface it in your own UI.
  • It is not editable — you can read and remove memory, but not hand-author its contents.
These boundaries keep the behavior predictable while leaving room to grow.