Memory systems for agents

6.2.5 · AI-ML › AI Agents & Tool Use

The Three-Layer Memory Architecture

Modern agent memory systems ek three-tier hierarchy use karte hain, jo human memory se inspired hai:

1. Working Memory (Short-Term)

Worked example Working Memory in Action

User: "Find me articles about climate change published after 2020." Working Memory Holds:

User Query: climate change articles, after 2020
Tool Call: search_arxiv(query="climate change", year_start=2021)
Tool Output: [5 papers with titles/abstracts]
Next Step: Filter by relevance, summarize top 3

WHY THIS STRUCTURE? Agent ko filtering step complete karne ke liye original request AUR search results dono ek saath chahiye. Working memory inhe "dimag mein" rakhti hai.

2. Episodic Memory (Mid-Term)

Worked example Episodic Memory: Customer Support Agent

Scenario: User Day 1 pe billing error ke baare mein support se contact karta hai. Day 5 pe follow-up karta hai. Day 1 Episode:

{
  "timestamp": "2026-06-26T10:00:00Z",
  "user_id": "user_123",
  "summary": "Billing error: charged twice for June subscription",
  "actions": ["issued_refund", "flaged_billing_system"],
  "outcome": "resolved"
}

Day 5 Query: "Is my refund processed?" Agent Retrieval:

Query ko embed karo → episodic memory mein search karo
Day 1 episode dhundho ("refund" se high similarity)
Working memory mein load karo: "User ka billing issue tha, 5 din pehle refund issue hua"
Refund status tool check karo → update ke saath respond karo WHY EPISODIC HELPS: Agent user se dobara problem explain nahi karwata. Woh wahan se shuru karta hai jahan chhoda tha.

3. Semantic Memory (Long-Term)

Formula Semantic Memory as Knowledge Graph

Purpose: Specific episodes se independent general facts, procedures, aur world knowledge store karna.

WHY: Episodic memory event-specific hoti hai. Semantic memory timeless knowledge hold karti hai:

"Python 0-based indexing use karta hai"
"Hamari API rate limit 100 requests/minute hai"
"User Alice morning meeting slots prefer karti hai" Structure: Knowledge graph ya key-value store $Fact = {entity, relation, value, confidence}$

Example:

("Python", "uses_indexing", "0-based", confidence=1.0)
("user_alice", "prefers_time", "09:00-11:00", confidence=0.85)

HOW IT UPDATES:

Extraction: Har interaction ke baad, episodic memory se facts extract karo
Deduplication: Existing facts ke saath merge karo (agar repeat ho toh confidence update karo)
Pruning: Jo facts naye evidence se contradict hon unhe remove karo

Worked example Semantic Memory: Code Assistant Agent

Scenario: User poochta hai, "How do I read a CSV in Python?" Semantic Memory Contains:

("pandas", "function_for", "CSV_reading", "pd.read_csv()")
("pandas.read_csv", "requires", "import pandas as pd")
("CSV", "common_parameters", "delimiter, header, dtype")

Agent Response Construction:

Semantic memory query karo: "CSV reading in Python"
Fact retrieve karo: pandas.read_csv
Related facts retrieve karo: import statement, common params

Answer synthesize karo:

import pandas as pd
df = pd.read_csv('file.csv')  # common params: delimiter=', header=0

WHY SEMANTIC? Agent ko yeh yaad rakhne ki zaroorat nahi ki "kis conversation ne mujhe pandas sikhaya." Yeh general knowledge hai, ek baar store hua, hamesha ke liye use hota hai.

Memory Operations: The Four Primitives

Saare memory systems chaar core operations implement karte hain:

Derivation: When to Forget?

Problem: Infinite memory → cost explosion + noise (irrelevant purana data).

Solution: Ek forgetting policy implement karo.

Approach 1: Recency-Based (Sliding Window) $Keep (e) = {10 if t_{now} - t_{e} < T_{window} otherwise$ Jahan $t_{e}$ episode $e$ ka timestamp hai, $T_{window}$ retention period hai (jaise 30 days).

WHY: Purana data relevant hone ki probability kam hoti hai. Implement karna simple hai.

Approach 2: Importance-Based $Importance (e) = w_{1} \cdot AccessCount (e) + w_{2} \cdot Recency (e) + w_{3} \cdot UserFeedback (e)$ Importance score ke hisaab se top-K rakho.

WHY THIS STEP? AccessCount → frequently use hone wale facts valuable hote hain. UserFeedback → user-starred items persist hone chahiye.

Approach 3: Semantic Redundancy Agar naye episode $e_{new}$ ka embedding $v_{new}$ hai aur existing episode $e_{old}$ ka $v_{old}$ hai: $cosine_sim (v_{new}, v_{old}) > 0.95 ⟹ Merge or Delete e_{old}$

WHY: Near-duplicate information store karne se bacho. Space bachata hai + retrieval noise kam karta hai.

Retrieval Strategies: How to Find the Right Memory

Derivation from First Principles:

WHY RELEVANCE? Agar agent "Python errors" discuss kar raha hai, toh "dinner recipes" ke baare mein memories retrieve karna context waste karta hai. Semantic similarity topical match ensure karti hai.
WHY RECENCY? Information decay hoti hai. Kal ki user preference ek saal purani preference se zyada reliable hai. Exponential decay $e^{- λ t}$ human forgetting curve model karta hai.
WHY IMPORTANCE? Kuch facts evergreen hote hain. "Hamare company ka policy on X" persist hona chahiye chahe recently access na hua ho. Access frequency yeh signal karta hai.
HOW TO COMBINE? Linear combination simple, interpretable, aur fast hai. Har term ko [0,1] mein normalize karo, phir weight lagao.

Step-by-step scoring:

Relevance (m_{i}, C) Recency (m_{i}) Importance (m_{i}) Score (m_{i}, C) = \frac{v _{m_{i}} \cdot v _{C}}{∥ v _{m_{i}} ∥∥ v _{C} ∥} \in [0, 1] = e^{- 0.1 \cdot days_ago} \in [0, 1] = \frac{access_count ( m _{i} )}{max _{j} access_count ( m _{j} )} \in [0, 1] = 0.7 \cdot Relevance + 0.2 \cdot Recency + 0.1 \cdot Importance

Memory Architectures in Practice

Pattern 1: Conversation Buffer Memory

Definition Buffer Memory

Conversation buffer memory working memory mein last N messages rakhti hai. Yeh sabse simple form hai.

Implementation:

class BufferMemory:
    def __init__(self, max_messages=10):
        self.buffer = []
        self.max max_messages
    
    def add(self, message):
        self.buffer.append(message)
        if len(self.buffer) > self.max:
            self.buffer.pop(0)  # FIFO

Pros: Simple, fast, koi retrieval logic nahi chahiye. Cons: Fixed size, koi semantic selection nahi, N se aage sab kuch bhool jaata hai.

Pattern 2: Summary Memory

Pattern 3: Vector Store Memory

Pattern 4: Hybrid Memory (Combining All Three)

Worked example Hybrid Memory: Personal Research Assistant

User Query: "Summarize the paper on attention mechanisms I read last month."

Memory Retrieval:

Working Memory: Current query (abhi-abhi)

Episodic Memory: "attention mechanisms" search karo → 2026-06-01 ka episode milta hai:

{
  "date": "2026-06-01",
  "action": "read_paper",
  "paper": "Attention Is All You Need (Vaswani et al.)",
  "notes": "Transformers use self-attention, no RNs..."
}
``` 3. **Semantic Memory**: "Vaswani et al." query karo → retrieve karo:
- "Transformer architecture has encoder-decoder"
- "Self-attention computes Q, K, V matrices"

Agent Response: Episodic (kaun sa paper) + semantic (usmein kya hai) combine karta hai → summary produce karta hai.

Common Mistakes & How to Avoid Them

Connections

Retrieval-Augmented Generation (RAG): Memory systems relevant context fetch karne ke liye RAG principles use karte hain.
Vector Databases: Episodic aur semantic memory aksar vector DBs (Pinecone, Chroma) mein store hoti hai.
LM Context Window Management: Working memory context window constraints ke andar fit hoti hai.
Knowledge Graphs: Semantic memory aksar knowledge graphs (entities + relations) ke roop mein structured hoti hai.
Prompt Engineering: Memory retrieval results ko effective prompts mein format karna padta hai.
Agent Planning and Reasoning: Memory woh "experience" provide karta hai jis par planning rely karti hai.
Multi-Agent Systems: Agents semantic memory share kar sakte hain (common knowledge base) jabki apni alag episodic memory maintain karte hain.

Recall Ek 12-Saal Ke Bachche Ko Explain Karo

Socho tum apne homework ke liye ek robot assistant bana rahe ho. Har baar jab tum usse kuch poochte ho, woh jawab deta hai, phir sab kuch bhool jaata hai. Toh agli baar jab tum poochho "What was my math homework?", woh bolta hai "I don't know, I just woke up!" Yeh annoying hoga na? Memory systems tumhare robot ko ek notebook dene jaisa hai:

Working memory = woh page jis par robot abhi likh raha hai (aaj ka homework)
Episodic memory = notebook ke purane pages (pichle hafte tumne kya homework kiya)
Semantic memory = ek cheat sheet jो robot ne useful facts ki banayi (jaise "math homework hamesha page 45 par hota hai")

Jab tum koi sawaal poochte ho, robot:

Current page dekhta hai (working memory)
Related cheez dhundne ke liye purane pages palatta hai (episodic memory)
General rules ke liye cheat sheet check karta hai (semantic memory) Is tarah, robot yaad karta hai ki tum pehle kya baat kar chuke ho, past mistakes se seekhta hai, aur waqt ke saath smarter hota jaata hai. Yeh aisa hai jaise ek study buddy ho jo actually dhyan deta hai!

Flashcards

#flashcards/ai-ml

Agent memory systems ki teeno layers kya hain? :: Working memory (short-term, current context), Episodic memory (mid-term, past interactions), Semantic memory (long-term, general knowledge).

Agents ko sirf conversation history se zyada memory kyun chahiye?

Interactions ke beech state maintain karne ke liye, experience se seekhne ke liye, long-term context build karne ke liye, aur sawaal ya galtiyan repeat karne se bachne ke liye.

Agent systems mein working memory kya hai?

Current task ke liye immediate context, LM ke context window mein stored, typically last few conversation turns plus active reasoning steps.

Episodic memory kya hai?

Past interaction sequences (episodes) ka ek store jo semantic search, temporal lookup, ya entity-based queries se retrieve kiya ja sakta hai. "Kab kya hua" archive karta hai.

Agents mein semantic memory kya hai?

Specific episodes se independent general facts, procedures, aur world knowledge ka long-term storage. Knowledge graphs ya key-value stores ke roop mein structured.

Chaar core memory operations kya hain?

Write (store), Read (retrieve), Update (modify), Forget (delete).

Memory systems mein forgetting important kyun hai?

Storage costs manage karne ke liye, irrelevant purane data se retrieval noise kam karne ke liye, performance improve karne ke liye, aur privacy requirements respect karne ke liye.

Memory retrieval scoring formula kya hai?

Score(m, C) = α·Relevance(m, C) + β·Recency(m) + γ·Importance(m), jahan α, β, γ weights hain (typically 0.7, 0.2, 0.1).

Conversation buffer memory kya hai?

Sabse simple memory type jo FIFO queue use karke working memory mein last N messages rakhti hai.

Summary memory kya hai?

Ek memory system jo raw messages ki jagah conversations ki compressed summaries store karta hai, space bachata hai lekin detail ki cost pe.

Vector store memory kya hai?

Embeddings ke roop mein vector database mein stored memory, jo nearest-neighbor retrieval ke zariye semantic search enable karti hai.

Hybrid memory architecture kya hai?

Ek system jo working memory (buffer), episodic memory (vector store), aur semantic memory (knowledge graph) ko smart retrieval routing ke saath combine karta hai.

Working memory ke liye capacity constraint kya hai?

Working Memory Size ≤ Context Window - System Prompt - Output Buffer

Recency-based forgetting kaise kaam karta hai?

Keep(e) = 1 agar t_now - t_e < T_window, warna 0. Retention window se purane memories delete karta hai.

Importance-based memory ranking kaise kaam karti hai?

Importance(e) = w1·AccessCount(e) + w2·Recency(e) + w3·UserFeedback(e). Importance score ke hisaab se top-K items rakhta hai.

Retrieval scoring mein relevance component kya hai?

Relevance(m, C) = cosine_similarity(embed(m), embed(C)), memory aur current context ke beech semantic similarity measure karta hai.

Retrieval scoring mein recency component kya hai? :: Recency(m) = e^(-λ(t_now - t_m)), human forgetting curves model karta hua ek exponential decay.

Semantic redundancy pruning kya hai?

Agar cosine_sim(v_new, v_old) > threshold (jaise 0.95) ho, toh duplicates store karne se bachne ke liye purani memory merge ya delete karo.

Saari history LM prompt mein kyun nahi daalni chahiye?

Context windows limited hain, irrelevant history noise add karti hai aur performance degrade karti hai, aur costs input token count ke saath linearly scale karti hain.

Sirf embedding similarity ki jagah hybrid scoring kyun use karein?

Pure similarity recency (outdated info) aur importance (rare lekin critical facts) miss karti hai. Hybrid scoring semantic match ko temporal aur usage signals ke saath balance karta hai.

Agar memories kabhi update na hon toh kya hota hai?

Stale facts persist karte hain (user preferences change hoti hain, APIs update hoti hain, facts outdated ho jaate hain), jis se agent khud se contradict karta hai ya galat information deta hai.

What Is Agent Memory?