interlocute.ai beta
Create a node

Memory

How Interlocute handles short-term and long-term context. Practical patterns for building AI that remembers.

What memory is

Memory allows your node to retain and recall context across conversations. Without memory, every interaction starts from scratch. With memory, the node can build on past interactions — remembering user preferences, prior decisions, and accumulated context.

Interlocute supports two levels of memory:

Short-term (thread)

Conversation history within a single thread. Automatically maintained as long as the thread exists.

Long-term (node)

Persistent memories that span across threads. Semantic retrieval surfaces relevant context from the node's entire interaction history.

How it works

When memory is enabled on a node, each interaction is automatically embedded and indexed. When a new message arrives, the platform performs a semantic lookup of past interactions and injects the most relevant context into the LLM prompt.

There is no database to manage and no retrieval logic to write. Enable memory, and it works.

Implementation guidance

  • Keep retrieved sources visible — when building UIs, consider showing users what context the node is drawing from. Transparency builds trust.
  • Summarize carefully — if you write custom logic that summarizes interactions into memory, be precise. Inaccurate summaries compound over time.
  • Respect user consent — if your use case involves personal data, ensure users are aware that their interactions may be stored. Provide clear retention policies.
  • Use TTL settings — configure time-to-live for memories when appropriate. Not all context needs to persist indefinitely.
Memory and RAG are complementary. Memory stores interaction-based context (what the user said). RAG stores document-based knowledge (what you uploaded). Both can be active on the same node.

Example: memory in action

// First interaction (new thread)
? "My name is Alex and I prefer dark mode."
? "Got it, Alex! I'll keep that in mind."

// Later interaction (different thread, same node)
? "What are my preferences?"
? "You've mentioned you prefer dark mode, Alex."

The second interaction uses a different thread but the node's long-term memory retrieves the relevant context from the earlier conversation.

Privacy considerations

  • Memory is isolated per node — one node's memories are never accessible to another node
  • You control retention via TTL settings
  • Memory data is subject to the same data handling policies as all Interlocute data

Next steps

Chit-ChatTriggers