AI Agent Memory Systems: Complete NCP-AAI Guide 2026

+-------------------------------------------------------------+
|                    PROCEDURAL MEMORY                        |
|  (Internalized Skills - Model Weights + Prompts + Code)     |
|  How to perform tasks; changes infrequently                 |
+-------------------------------------------------------------+
                            |
                    Informs behavior
                            |
+-------------------------------------------------------------+
|                    SEMANTIC MEMORY                           |
|  (Persistent Facts & Knowledge)                             |
|  User preferences, domain knowledge, entity relationships   |
+-------------------------------------------------------------+
                            |
                    Provides context
                            |
+-------------------------------------------------------------+
|                    EPISODIC MEMORY                           |
|  (Sequential Experiences)                                   |
|  Conversation history, action traces, task execution logs   |
+-------------------------------------------------------------+
                            |
                    Feeds into
                            |
+-------------------------------------------------------------+
|                SHORT-TERM (WORKING) MEMORY                  |
|  (Current Context Window: 4K-200K tokens)                   |
|  Active conversation, current task state                    |
+-------------------------------------------------------------+

User: "What's the weather in Tokyo?"
Agent: [Calls get_weather] "18C, partly cloudy"
User: "What about tomorrow?"
Agent: [Needs short-term memory to know "tomorrow" refers to Tokyo]

Session 1 (Monday):
  User: "I prefer vegetarian restaurants"
  Agent: [Stores to long-term memory]

Session 2 (Friday):
  User: "Recommend a lunch spot"
  Agent: [Retrieves preference] "Here's a great vegetarian cafe nearby..."

{
  "episode_id": "ep_20251209_001",
  "timestamp": "2025-12-09T14:23:00Z",
  "user_id": "user_456",
  "conversation": [
    {"role": "user", "content": "Book a flight to Paris"},
    {"role": "agent", "content": "I found 3 options...", "tool_calls": ["search_flights"]},
    {"role": "user", "content": "Choose the cheapest"},
    {"role": "agent", "content": "Booked Flight AF123", "tool_calls": ["book_flight"]}
  ],
  "outcome": "success",
  "tools_used": ["search_flights", "book_flight"]
}

Semantic Memory Storage:
  - "User prefers window seats on flights" [confidence: 0.95]
  - "User allergic to peanuts" [confidence: 1.0]
  - "User's home airport: JFK" [confidence: 1.0]
  - "User typically books economy class" [confidence: 0.78]

Agent uses these facts WITHOUT needing to recall the specific
conversations where they were mentioned.

system_prompt = """
You are a customer support agent. Your procedural knowledge:
- Always greet users politely
- Verify customer identity before sharing account information
- Use the search_knowledge_base tool for technical questions
- Escalate to human agents if customer is frustrated (sentiment < 0.3)
- Follow GDPR guidelines when accessing personal data
"""

Exam Calculation Example:

Scenario: Agent maintains 50 past messages, averaging 150 tokens each.
  - Total context: 50 x 150 = 7,500 tokens
  - System prompt: 1,200 tokens
  - Current tools: 2,000 tokens (15 tool schemas)
  - Working space needed: 2,000 tokens (response generation)
  - Total required: 7,500 + 1,200 + 2,000 + 2,000 = 12,700 tokens

If model has 8K (8,192 tokens) context window, what happens?

Correct Answer: Context overflow---agent cannot include all past messages. Need memory management strategy.

Memory Management Strategies

Strategy 1: Sliding Window (ConversationBufferWindowMemory)

Description: Keep only the N most recent messages.

LangChain Implementation:

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(
    k=5,  # Keep only last 5 turns
    memory_key="recent_history",
    return_messages=True
)

# Automatically maintains sliding window
# Messages 1-5: all kept
# Message 6 added -> Message 1 discarded
# Message 7 added -> Message 2 discarded

Pros:

• Simple to implement
• Predictable token usage: max = k x avg_message_length
• Bounded cost per LLM call

Cons:

• Loses older context entirely
• Forgets important earlier information
• Arbitrary cutoff

Exam Question: "Sliding window with N=10 loses critical user info from message 1. What's wrong?" -> Answer: Window size too small for task complexity (increase N or use summarization).

Strategy 2: Summarization (ConversationSummaryMemory)

Description: Compress older messages into summaries.

LangChain Implementation:

from langchain.memory import ConversationSummaryMemory
from langchain.llms import OpenAI

memory = ConversationSummaryMemory(
    llm=OpenAI(temperature=0),
    memory_key="conversation_summary"
)

# After each exchange, LLM generates running summary
memory.save_context(
    {"input": "Tell me about quantum computing"},
    {"output": "Quantum computing uses qubits that can exist in superposition..."}
)

# Summary: "The user is learning about quantum computing.
#           Agent explained qubits and superposition."

Before summarization (3,500 tokens):

Original messages 1-10:
  User: "I need to book a flight..."
  Agent: "I found 5 options..."
  User: "Tell me more about..."
  [... 7 more exchanges ...]

After summarization (250 tokens):

"User requested flight to Paris for Dec 16-22, selected Flight AF123 (487 EUR),
 provided passport details, confirmed booking PNR456."

Pros:

• Retains key information
• Reduces token usage by 80-95%
• Constant memory footprint, scales to long conversations

Cons:

• Requires LLM call to generate summary (cost + latency)
• May lose nuance or details
• Potential summarization inaccuracies

Exam Tip: Summarization is best for completed sub-tasks, not active conversations.

Strategy 3: Token Buffer Memory

Description: Manages memory by token count rather than turn count---more precise than window memory.

from langchain.memory import ConversationTokenBufferMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI()
memory = ConversationTokenBufferMemory(
    llm=llm,
    max_token_limit=1000  # Stay within budget
)

Pros: Precise cost control, adaptive to variable message lengths Cons: Requires tokenizer, slightly more complex than window memory

Strategy 4: Semantic Retrieval (VectorStoreMemory)

Description: Store all messages in vector database, retrieve relevant ones based on current query.

LangChain Implementation:

from langchain.memory import VectorStoreMemory
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

memory = VectorStoreMemory(
    vectorstore=FAISS.from_texts(
        texts=[],  # Initially empty
        embedding=OpenAIEmbeddings()
    ),
    memory_key="relevant_context",
    top_k=3  # Retrieve 3 most relevant past exchanges
)

# All messages indexed in vector store
memory.save_context(
    {"input": "My name is Alice and I work on the Phoenix project"},
    {"output": "Nice to meet you, Alice! How can I help with Phoenix?"}
)

# ... 100 messages later ...

# Retrieves ONLY relevant historical context
context = memory.load_memory_variables(
    {"prompt": "What project does Alice work on?"}
)
# Returns: Previous message about Alice and Phoenix project

Pros:

• Retains full detail of relevant messages
• Efficient token usage (only relevant context)
• Handles thousands of messages without token limits
• Combines episodic and semantic retrieval patterns

Cons:

• Requires vector database infrastructure
• Retrieval latency (10-50ms)
• May miss important but semantically distant information

Exam Question: "Agent needs to recall specific booking confirmation from 50-message history. Which strategy?" -> Answer: Semantic retrieval (finds exact relevant message efficiently).

Strategy 5: Hierarchical Memory (Production Best Practice)

Description: Combine multiple strategies---recent messages in full, older messages summarized, semantic retrieval for specific facts.

Exam Scenario:

Context Budget: 8,000 tokens

Allocation:
  - System prompt: 1,000 tokens
  - Tool schemas: 1,500 tokens
  - Recent messages (last 5): 2,000 tokens [FULL DETAIL]
  - Summary of messages 6-20: 500 tokens [SUMMARIZED]
  - Retrieved facts from long-term memory: 1,000 tokens [SEMANTIC SEARCH]
  - Working space: 2,000 tokens [RESPONSE GENERATION]

Total: 8,000 tokens

Implementation Pattern:

class HierarchicalMemory:
    def __init__(self):
        # Tier 1: Working memory (in-context, instant)
        self.working_memory = ConversationBufferWindowMemory(k=3)

        # Tier 2: Short-term episodic (current session buffer)
        self.session_memory = []

        # Tier 3: Long-term semantic (vector store)
        self.knowledge_base = Chroma(...)

        # Tier 4: Long-term episodic (past sessions)
        self.episodic_store = Pinecone(...)

    def retrieve(self, query):
        # Stage 1: Check working memory (instant)
        working = self.working_memory.load_memory_variables({})

        # Stage 2: Search session memory (fast, local)
        session_relevant = self._search_session(query)

        # Stage 3: Query long-term semantic (vector search, 10-35ms)
        knowledge = self.knowledge_base.similarity_search(query, k=3)

        # Stage 4: Query episodic if needed (conditional, slower)
        episodes = []
        if self._needs_history(query):
            episodes = self.episodic_store.similarity_search(query, k=2)

        return self._merge_memories(working, session_relevant,
                                     knowledge, episodes)

Exam Question: "Agent needs both recent context AND distant facts. Which memory architecture?" -> Answer: Hierarchical memory (combines multiple strategies for optimal coverage).

Strategy 6: Entity Memory

Description: Track specific entities (people, products, topics) across conversations.

from langchain.memory import ConversationEntityMemory

entity_memory = ConversationEntityMemory(llm=llm)

entity_memory.save_context(
    {"input": "John prefers the NCP-AAI practice tests on Preporato"},
    {"output": "Great! Preporato offers comprehensive NCP-AAI practice bundles."}
)

# Automatically extracts entities
print(entity_memory.entity_store)
# {
#   "John": "Prefers NCP-AAI practice tests on Preporato",
#   "Preporato": "Offers comprehensive NCP-AAI practice bundles"
# }

# Later reference
memory_vars = entity_memory.load_memory_variables(
    {"input": "What does John like?"}
)
# Retrieves: "John prefers the NCP-AAI practice tests on Preporato"

Use Cases: Tracking user entities, project details, and relationship data across conversations without full episode replay.

State Management Patterns

Stateless vs. Stateful Agents

Stateless Agent (Exam Contrast):

Request 1: "Book flight to Tokyo"
  [Agent processes, returns result]
  [All context discarded]

Request 2: "What was the price?"
  [Agent has NO memory of Request 1]
  FAILS

Stateful Agent (Exam Answer):

Request 1: "Book flight to Tokyo"
  [Agent processes, stores state: {"last_booking": "Flight NH005", "price": "$847"}]

Request 2: "What was the price?"
  [Agent retrieves state]
  "The flight to Tokyo (Flight NH005) was $847."

Exam Question: "Agent loses context between API calls. What architectural component is missing?" -> Answer: State persistence layer (stateful design with session storage).

State Storage Options

Exam Scenario: "Agent tracks user preferences, conversation history, and entity relationships. Which storage?" -> Answer: Hybrid approach---Vector DB (preferences via semantic search) + Graph DB (entity relationships).

LangGraph State Management and Checkpointing

LangGraph provides the standard state management framework for agentic AI workflows. Its checkpointing system saves agent state to persistent storage after each step, enabling fault-tolerant, resumable workflows.

State Schema Design

from typing import TypedDict, List, Annotated
from langgraph.graph import StateGraph, add_messages

class AgentState(TypedDict):
    """State schema for agent with episodic memory"""
    messages: Annotated[List[dict], add_messages]  # Conversation history
    task_steps: List[dict]       # Sequential actions taken
    current_goal: str            # What agent is trying to accomplish
    failed_attempts: List[dict]  # Previous failures (learn from mistakes)
    user_id: str                 # Who agent is interacting with

Checkpointing for Fault Tolerance

from langgraph.checkpoint.sqlite import SqliteSaver
from langgraph.checkpoint.postgres import PostgresSaver

# SQLite for development
checkpointer = SqliteSaver.from_conn_string("./agent_memory.db")

# PostgreSQL for production (enterprise-grade)
checkpointer = PostgresSaver.from_conn_string(
    "postgresql://user:pass@localhost/agent_memory"
)

graph = StateGraph(AgentState)
# ... add nodes ...
app = graph.compile(checkpointer=checkpointer)

# Each conversation has a unique thread_id
config = {"configurable": {"thread_id": "conversation_42"}}

# Agent maintains full state across sessions
result = app.invoke(
    {"messages": [("user", "Hello")]},
    config=config
)

# Later, resume same conversation---state loaded from checkpoint
result = app.invoke(
    {"messages": [("user", "What did we talk about earlier?")]},
    config=config  # Same thread_id loads previous history
)

Workflow State Tracking Pattern

from enum import Enum

class TaskStatus(Enum):
    NOT_STARTED = "not_started"
    IN_PROGRESS = "in_progress"
    WAITING_INPUT = "waiting_input"
    COMPLETED = "completed"
    FAILED = "failed"

class WorkflowState(TypedDict):
    task_id: str
    status: TaskStatus
    completed_steps: List[str]
    pending_steps: List[str]
    current_step: str
    retry_count: int
    error_log: List[str]

def order_fulfillment_agent(state: WorkflowState):
    """Agent resumes from exactly where it left off"""

    if "verify_inventory" not in state["completed_steps"]:
        result = verify_inventory()
        state["completed_steps"].append("verify_inventory")

    if "process_payment" not in state["completed_steps"]:
        result = process_payment()
        state["completed_steps"].append("process_payment")

    if "ship_order" not in state["completed_steps"]:
        result = ship_order()
        state["completed_steps"].append("ship_order")

    state["status"] = TaskStatus.COMPLETED
    return state

State Persistence Benefit: If the search API rate limits are hit at step 2, the workflow can pause and resume hours later without losing progress.

Memory Retrieval Strategies (Exam Critical)

Retrieval Algorithms

1. Recency-Based Retrieval

Algorithm: Return N most recent items.

Exam Use Case: "Show me my last 3 bookings" (chronological, not semantic).

SELECT * FROM bookings
WHERE user_id = 456
ORDER BY created_at DESC
LIMIT 3;

Exam Tip: Best for time-sensitive queries, NOT for conceptual questions like "What are my preferences?"

2. Semantic Similarity Retrieval

Algorithm: Return N items with highest embedding similarity to query.

query_embedding = embed("flight cancellations")  # [768-dim vector]

results = vector_db.search(
    query_vector=query_embedding,
    top_k=5,
    similarity_metric="cosine"
)

# Returns messages like:
#   - "I need to cancel my Tokyo flight" [similarity: 0.92]
#   - "Policy for flight changes and cancellations" [similarity: 0.88]

Exam Question: "Agent must find conceptually related messages without exact keyword match. Which retrieval?" -> Answer: Semantic similarity (embedding-based search).

3. Maximal Marginal Relevance (MMR)

Algorithm: Balance relevance and diversity to avoid redundant results.

# Balance relevance and diversity
results = memory.max_marginal_relevance_search(
    query,
    k=5,
    fetch_k=20,     # Fetch 20 candidates, return diverse 5
    lambda_mult=0.7  # 0=max diversity, 1=max relevance
)

When to use: When semantic search returns too many near-identical results. MMR ensures the top-K results cover different aspects of the query.

4. Metadata-Filtered Retrieval

Algorithm: Combine semantic search with structured filters.

results = memory.similarity_search(
    query,
    k=5,
    filter={"user_id": "user123", "date_range": "2025-01"}
)

Exam Use Case: Multi-tenant systems where user data must be isolated.

5. Hybrid Retrieval (Keyword + Semantic)

Algorithm: Combine BM25 keyword search and vector similarity.

from langchain.retrievers import EnsembleRetriever

keyword_retriever = BM25Retriever.from_texts(texts)
vector_retriever = memory.as_retriever()

ensemble = EnsembleRetriever(
    retrievers=[keyword_retriever, vector_retriever],
    weights=[0.3, 0.7]  # Favor semantic
)

When to use: When exact keyword matching matters (product IDs, error codes) alongside semantic understanding.

6. Weighted Hybrid Scoring (Exam Tested)

Algorithm: Combine recency + relevance + importance.

Scoring Formula: