⬡ Overview
◈ Memory Types
▶ Simulator
⌖ System Design
✦ Memory ↔ RAG
↻ Retrieval Flow
⚙ Implement
◇ Check
★ Results
0 / 5
Hands-On Lab  ·  Module 8  ·  BAA 8.0

Conversational
Memory

Without memory, every message is a first introduction. With memory, an agent builds a model of the user across time — referencing what was said, what was decided, and what still matters. In this lab you design, simulate, architect, and implement conversational memory — and learn why it's the same mechanism as RAG.

Learning Objectives
01
Distinguish the three memory layers — buffer, summary, and vector — and explain when each is appropriate.
02
Experience the difference between a memoryless agent and a memory-enabled agent through an interactive simulator.
03
Design the system architecture for a memory-enabled agent — placing components correctly in a data-flow diagram.
04
Explain how conversational memory and RAG share the same core mechanism — and where they diverge.
Your Lab Roadmap
—
Memory Types Explorer
Click Buffer · Summary · Vector to understand each memory layer and when to use it
1
Live Chat Simulator
Converse with a memoryless vs. memory-enabled agent — side by side — and see exactly what breaks without memory
2
System Design Canvas
Drag architecture components into the correct positions in a memory-enabled agent data-flow diagram
—
Memory ↔ RAG Connection
Explore the shared mechanism — and the critical difference — between conversational memory and RAG
3
Retrieval Flow Sequencer
Drag 7 steps into the correct order for how a memory-enabled agent retrieves and uses past context
4
Implementation Guide
Step-by-step: add conversation memory to a Flowise or Relevance AI prototype
5
Knowledge Check
7 questions · memory layers, RAG, system design · 70% to pass
The Foundation

Three Memory Layers

Every memory-enabled agent uses one or more of these three layers. Click each to explore what it stores, how it works, and when it breaks.

🪣 Buffer Memory
📝 Summary Memory
🔮 Vector Memory
Click a memory type above to explore it.
Lab Activity — Classify Conversation Turns

Memory Classification

Each fragment below is a piece of information from a conversation. Drag it to the memory layer best suited to store and retrieve it.

Unclassified conversation fragments
On mobile? Tap to assign
Section 01 · Interactive Demo

Memory Simulator

Two agents. Same LLM. One has memory — one doesn't. Have a 3-turn conversation about yourself. Watch what happens when you reference something you said earlier.

💡 How to use this: Type messages in either input box. Try saying "My name is [your name], I work in [your field]" first — then follow up with "What's my name?" or "What did I say my job was?" The difference will be immediately clear.
🚫
No Memory
Stateless — forgets after every message
CONVERSATION
🧠
With Buffer Memory
Retains full conversation window
CONVERSATION
Section 02 · Systems Design Lab

Architecture Canvas

A memory-enabled agent is a system — not just a prompt. Drag each component into its correct position in the data-flow diagram. Each slot has one right answer.

🔧 Systems Design Thinking: Every box in this diagram answers a question: Who stores it? Who retrieves it? Who transforms it? Who decides what to do with it? Think about the data's journey from user mouth to agent response.
Component Pool — drag to the correct slot in the diagram
The Big Idea

Memory ↔ RAG

Here's a secret most courses skip: conversational memory and RAG are the same core mechanism — just applied to different knowledge sources. Understanding why this is true unlocks both concepts.

Conversational Memory
Knowledge base: Past conversation turns
Query: The user's current message
Retrieval: Find relevant prior turns by recency or semantic similarity
Augmentation: Inject retrieved turns into the LLM context before generating
Generation: LLM produces a contextually coherent response
RAG (Retrieval-Augmented Generation)
Knowledge base: External documents, databases, websites
Query: The user's current message
Retrieval: Find relevant documents by semantic similarity (embeddings)
Augmentation: Inject retrieved chunks into the LLM context before generating
Generation: LLM produces a factually grounded response
🔮 The shared pattern: Both are Retrieve → Augment → Generate. The only difference is what's in the knowledge base — your own conversation history vs. external documents. A production agent often uses both at the same time: conversational memory for who the user is and what they've said, RAG for domain knowledge the LLM wasn't trained on.
Where They Diverge
Dimension
Conversational Memory
RAG
${[ ['Knowledge freshness','Grows during the session — dynamic','Static corpus, updated offline'], ['Source of truth','The user themselves','External documents or databases'], ['Retrieval strategy','Recency-weighted OR semantic similarity','Semantic similarity (cosine distance)'], ['Forgetting','Buffer fills up → oldest turns dropped or summarized','Corpus doesn\'t change unless re-indexed'], ['Privacy risk','Contains PII — requires careful handling','Usually impersonal — lower PII risk'], ['Scale','Small (one conversation)','Large (millions of documents)'], ].map(([dim,mem,rag])=>`
${dim}
${mem}
${rag}
`).join('')}
System Design Implication

When you design a production agent, you typically wire up two vector stores in parallel: one for the conversation history (short-lived, per-session, PII-aware) and one for the domain knowledge base (persistent, shared, RAG-style). The LLM's context window gets injected with retrieved chunks from both before generating — the agent "knows who it's talking to" AND "knows its domain." This is called Hybrid Memory Architecture.

Section 03 · Lab Activity

Retrieval Flow Sequencer

Memory doesn't just "happen" — it's an 8-step pipeline. Drag the steps into the correct execution order, from the moment the user sends a message to the moment the agent replies.

💡 Hint: Think RAG: first you receive, then you retrieve, then you inject, then you generate. But before any retrieval can happen — the history must have been stored and embedded in the first place.
Section 04 · Implementation

Implement Memory

Pick your platform and follow the guide. Each path adds real conversation memory to a working prototype agent.

Section 05

Knowledge Check

7 questions covering memory types, system design, and the RAG connection. 70% to pass.

Question 1 of 7Score: 0 / 0
Lab Debrief

Lab Complete