Maintain Context over time, adapt to our preferences\u00a0, learn from our past instructions<\/p>\n
AI applications need memory to share context across multiple interactions. In LangGraph, you can add two types of memory: (Read More<\/a>: How to Add Memory to LLM Applications<\/a>)<\/p>\n Add short-term memory<\/strong> as a part of your agent\u2019s state to enable multi-turn conversationsAdd long-term memory<\/strong> to store user-specific or application-level data across\u00a0sessions<\/p>\n Long-term Agentic Memory in LangGraph transforms AI agents from forgetful bots into genuinely helpful assistants that learn, adapt, and personalize <\/em>over time a game-changer for building practical agentic workflows.<\/p>\n We all know that AI agents are stateless<\/em> without memory, AI agents are limited to responding in short, exchanges missing the crucial ability to recall context, preferences, and past events. When an agent \u201cremembers\u201d several capabilities become possible:<\/p>\n Adapting<\/strong> to user preferences and\u00a0historyProviding<\/strong> contextual, relevant answers across conversationsLearning<\/strong> new skills or facts and evolving responsesDelivering<\/strong> highly personalized experiences<\/p>\n LangGraph makes these capabilities accessible through its modular approach to agent memory, supporting diverse storage and retrieval strategies.<\/p>\n Humans use memories to remember facts (semantic memory<\/a>), experiences (episodic memory<\/a>), and rules (procedural memory<\/a>). AI agents can use memory in the same ways. For example, AI agents can use memory to remember specific facts about a user to accomplish a\u00a0task.<\/p>\n Let\u2019s understand this by an example. As data scientists, we often build internal tools to streamline workflows. Imagine we\u2019re tasked with creating a project management assistant for a software team lead, Mr John. Her team is working on a major Q3 feature launch, codenamed \u201cProject\u00a0Marvel.\u201d<\/strong><\/p>\n Source<\/a><\/p>\n Sam sends a simple message to the assistant:<\/p>\n \u201cHey, what\u2019s the status on the \u2018Marvel\u2019 release?\u201d<\/p>\n If our \u201cagent\u201d is just a simple pass-through to a raw LLM, we see the immediate failure of statelessness. The LLM, with its vast general knowledge<\/strong> but zero local context<\/strong>, would likely\u00a0reply:<\/p>\n \u201cHey\u200a\u2014\u200acould you clarify which \u201cMarvel\u201d release you mean? Here are a few recent updates; maybe one matches your reference:Marvel Zombies premiered September 24, 2025, on\u00a0DisneyThe Fantastic Four: First Steps is scheduled for July 25, 2025 in theaters.Spider-Man: Brand New Day (Spider-Man 4) is set for July\u00a02026.Avengers: Doomsday is currently slated for December 18,\u00a02026.<\/p>\n This response is practically useless. It forces the user to do all the work of providing context. Now, let\u2019s see how an agent with a proper memory architecture would handle this.Lets discuss these memory types and its\u00a0analogy.<\/p>\n Source<\/a><\/p>\n Things you just know, like the capital of France or facts you learned in school. It\u2019s your internal library of knowledge.<\/p>\n Semantic Memory<\/strong> is the agent\u2019s collection of hard facts. It\u2019s a database of objective information about you, the world, and the people it interacts with. This isn\u2019t about remembering the full chat history, it\u2019s about pulling out the important truths from that chat and filing them away for\u00a0later.<\/p>\n How it works for an agent:<\/strong> # ======================================== In our \u201cProject Marvel\u201d example, this was the agent\u2019s knowledge that \u201cJohn Martinez is the Senior Team Lead managing Project Marvel\u200a\u2014\u200aQ3 feature launch with 8 team members\u201d. These factual details were the key that helped the agent understand the context and technical specification.<\/p>\n Remembering specific events, like your first day at a new job or the exact words of a conversation you had yesterday.<\/p>\n Episodic Memory<\/strong> is about recalling specific events, just as they happened. It\u2019s not a single fact, but the entire replay of a past experience. For an agent, this is like a recording of a previous job it did what it saw, what it did, and how it all turned\u00a0out.<\/p>\n How it works for an agent:<\/strong> # ======================================== test_message_1 = { We’ve hit a critical blocker on the authentication microservice integration for Project Marvel. The OAuth flow is failing in staging environment.<\/p>\n Error: Token validation failing with 401 on \/marvel\/auth\/verify<\/p>\n This is blocking 3 developers from completing their sprint tasks. Can we schedule a quick sync to debug this today?<\/p>\n Impact: High – affects core functionality for Q3 launch<\/p>\n Thanks, def triage_router(state: State) -> Command[Literal[“response_agent”, “__end__”]]: # SEMANTIC + EPISODIC MEMORY: Combine general knowledge with specific context In our example, this was the agent recalling the specific experience of Sarah Chen\u2019s urgent message on Tuesday morning about the OAuth authentication failing with a 401 error on the \/marvel\/auth\/verify endpoint, which was blocking 3 developers and threatening the Q3 launch deadline. This wasn\u2019t a general rule, but the complete contextual memory of that specific incident requiring immediate escalation.<\/p>\n Skills and habits you don\u2019t have to think about, like riding a bike or typing. It\u2019s the \u201chow-to\u201d knowledge that\u2019s become second\u00a0nature.<\/p>\n Procedural Memory<\/strong> is the agent\u2019s set of core principles and instincts. It\u2019s the rulebook that defines its personality, its style, and how it operates. Think of it less as a stored\u00a0memory.<\/p>\n How it works for an agent:<\/strong> # ======================================== @tool @tool def call_gemini_for_triage(system_prompt: str, user_prompt: str) -> Router: # PROCEDURAL MEMORY: Steps for parsing JSON responses try: # PROCEDURAL MEMORY: Decision tree for routing based on classification For the project assistant, the procedural memory was its fundamental learned process: \u201cWhen you receive a message with \u2018BLOCKER\u2019 in the subject line from a team member, immediately classify it as \u2018respond\u2019, then execute the sequence:<\/p>\n create_jira_ticket() \u2192 schedule_standup() \u2192 send_slack_message()<\/p>\n to coordinate the response.\u201d This step-by-step procedure was what told the agent exactly how to handle Sarah\u2019s authentication blocker systematically and efficiently.<\/p>\n def project_assistant(message_input: Dict) -> Dict: # Step 1: Triage the message result = { # Step 2: If needs response, generate one return result<\/p>\n Now Lets test some\u00a0cases,<\/p>\n CASE 1: Critical Blocker\u00a0Report:<\/p>\n test_message_1 = { We’ve hit a critical blocker on the authentication microservice integration for Project Marvel. The OAuth flow is failing in staging environment.<\/p>\n Error: Token validation failing with 401 on \/marvel\/auth\/verify<\/p>\n This is blocking 3 developers from completing their sprint tasks. Can we schedule a quick sync to debug this today?<\/p>\n Impact: High – affects core functionality for Q3 launch<\/p>\n Thanks, Classification: RESPOND\u200a\u2014\u200aThis message requires\u00a0action<\/p>\n Reasoning: The message explicitly states a \u2018critical blocker\u2019 on Project Marvel, which is John\u2019s project. It details the issue (OAuth flow failing), provides an error, and highlights a significant impact (blocking 3 developers, affecting core functionality for Q3 launch). The sender, Sarah, is likely a team member, and she directly requests \u2018a quick sync to debug this\u00a0today\u2019\u2026\u2026<\/p>\n # Executing tool: schedule_standup with parameters: ## Generated Response: CASE 2: Company Announcement<\/p>\n test_message_2 = { Just a friendly reminder that our annual Health & Wellness Week is coming up next month!<\/p>\n Activities include: Sign up on the company portal.<\/p>\n Best, Classification: IGNORE\u200a\u2014\u200aThis message can be\u00a0skipped<\/p>\n Reasoning: The message is from \u2018Company Wide\u2019 to \u2018All Employees\u2019 and is a \u2018Reminder: Health & Wellness Week Next Month\u2019. This is a classic example of a general company announcement. According to the rules, \u2018General company announcements\u2019 are messages that are not worth responding to or tracking.<\/p>\n Long-term agentic memory in LangGraph transforms AI agents from forgetful bots into intelligent assistants that learn and adapt over time. By implementing semantic, episodic, and procedural memory systems, you can create agents\u00a0that:<\/p>\n Remember: memory is not just about storage it\u2019s about creating agents that become more valuable with every interaction, just like human assistants who learn your preferences and working style over\u00a0time.<\/p>\n Thank you for reading!\ud83e\udd17I hope that you found this article both informative and enjoyable to\u00a0read.<\/p>\n Fore more information like this follow me on\u00a0LinkedIn<\/em><\/a><\/p>\n Understanding Long-Term Memory in LangGraph: A Hands-On Guide<\/a> was originally published in Coinmonks<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>","protected":false},"excerpt":{"rendered":" Maintain Context over time, adapt to our preferences\u00a0, learn from our past instructions AI applications need memory to share context across multiple interactions. In LangGraph, you can add two types of memory: (Read More: How to Add Memory to LLM Applications) Add short-term memory as a part of your agent\u2019s state to enable multi-turn conversationsAdd […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-104328","post","type-post","status-publish","format-standard","hentry","category-interesting"],"_links":{"self":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/104328"}],"collection":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=104328"}],"version-history":[{"count":0,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/104328\/revisions"}],"wp:attachment":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=104328"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=104328"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=104328"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Why Long-Term Memory\u00a0Matters<\/h3>\n
The Core Memory\u00a0Types<\/h3>\n
1. Semantic Memory: The Agent\u2019s Fact\u00a0Book<\/h3>\n
This is usually a vector store<\/strong> working behind the scenes. The agent gets tools like send_slack_message, create_jira_ticket, schedule_standup, check_sprint_capacity\u00a0. When it learns something new and important during a conversation, it saves it using update_project_status. Later on, when it needs to make a decision, it can instantly look up relevant facts to get the context it\u00a0needs.<\/p>\n
# SEMANTIC MEMORY: General knowledge about project management rules and procedures
# ========================================
# This contains factual knowledge about how to categorize and handle different types of
prompt_instructions = {
“triage_rules”: {
“ignore”: “General company announcements, unrelated project updates, promotional
content”,
“notify”: “Sprint retrospective notes, deployment status updates, team
availability changes”,
“respond”: “Blocker reports from team members, stakeholder requests, urgent bug
escalations”,
},
“agent_instructions”: “Use these tools to help John manage Project Marvel tasks and
team coordination efficiently.”
}
profile = {
“name”: “John”,
“full_name”: “John Martinez”,
“user_profile_background”: “Senior Team Lead managing Project Marvel – Q3 feature launch with 8 team members”,
}
# SEMANTIC MEMORY: Knowledge about available tools and their mapping
tools_map = {
“send_slack_message”: send_slack_message,
“create_jira_ticket”: create_jira_ticket,
“schedule_standup”: schedule_standup,
“check_sprint_capacity”: check_sprint_capacity,
“update_project_status”: update_project_status
}<\/p>\n2. Episodic Memory: The Agent\u2019s Lived Experience<\/h3>\n
This is a fantastic way to create few-shot examples<\/strong>. By giving the agent a \u201cdiary\u201d of its past successes, we can guide it to make better choices in the future. It\u2019s a powerful way to show<\/em>, not just tell<\/em>, the agent how to act, which makes it far more reliable.<\/p>\n
# EPISODIC MEMORY: Specific test scenarios and experiences
# ========================================
# These represent specific examples of messages that the system has learned to handle<\/p>\n
“author”: “Sarah Chen <sarah.chen@company.com>”,
“to”: “John Martinez <john.martinez@company.com>”,
“subject”: “BLOCKER: API Integration Issue for Project Marvel”,
“message_thread”: “””Hi John,<\/p>\n
Sarah”””,
}<\/p>\n
“””PROCEDURAL MEMORY: How to route messages based on triage classification.”””
# EPISODIC MEMORY: Extract specific message details from current context
author = state[‘message_input’][‘author’]
to = state[‘message_input’][‘to’]
subject = state[‘message_input’][‘subject’]
message_thread = state[‘message_input’][‘message_thread’]<\/p>\n
system_prompt = triage_system_prompt.format(
full_name=profile[“full_name”],
name=profile[“name”],
user_profile_background=profile[“user_profile_background”],
triage_no=prompt_instructions[“triage_rules”][“ignore”],
triage_notify=prompt_instructions[“triage_rules”][“notify”],
triage_email=prompt_instructions[“triage_rules”][“respond”],
)<\/p>\n3. Procedural Memory: The Agent\u2019s Muscle\u00a0Memory<\/h3>\n
This is the agent\u2019s system prompt<\/strong>. The system prompt acts as its constitution or its prime directives a set of instructions it follows at all times. This is what ensures the agent is consistent, safe, and acts the way you want it\u00a0to.<\/p>\n
# PROCEDURAL MEMORY: Skills and action-oriented tools
# ========================================
# These functions represent learned procedures for executing project management tasks<\/p>\n
def create_jira_ticket(
title: str,
description: str,
priority: str,
assignee: str
) -> str:
“””PROCEDURAL MEMORY: How to create and track project tasks.”””
return f”JIRA ticket created: ‘{title}’ – Priority: {priority}, Assigned to: {assignee}”<\/p>\n
def schedule_standup(
attendees: list[str],
topic: str,
duration_minutes: int,
preferred_time: str
) -> str:
“””PROCEDURAL MEMORY: How to organize and schedule team meetings.”””
return f”Meeting ‘{topic}’ scheduled for {preferred_time} with {len(attendees)} attendees ({duration_minutes} min)”<\/p>\n
“””PROCEDURAL MEMORY: How to classify and triage incoming messages.”””
model = genai.GenerativeModel(GEMINI_MODEL_NAME)<\/p>\n
if response_text.startswith(““`json”):
response_text = response_text[7:]
if response_text.endswith(““`”):
response_text = response_text[:-3]
response_text = response_text.strip()<\/p>\n
result_dict = json.loads(response_text)
return Router(**result_dict)
except json.JSONDecodeError:
# PROCEDURAL MEMORY: Error handling – default to notify for safety
return Router(
reasoning=”Failed to parse response, defaulting to notify”,
classification=”notify”
)<\/p>\n
if result.classification == “respond”:
print(“\ud83c\udfaf Classification: RESPOND – This message requires action”)
print(f”Reasoning: {result.reasoning}”)
goto = “response_agent”
update = {
“messages”: [
{
“role”: “user”,
“content”: f”Handle this Project Marvel message: {state[‘message_input’]}”,
}
]
}
elif result.classification == “ignore”:
print(“\u23ed\ufe0f Classification: IGNORE – This message can be skipped”)
print(f”Reasoning: {result.reasoning}”)
update = None
goto = END<\/p>\nMAIN SYSTEM ORCHESTRATION<\/h4>\n
“””Main function that orchestrates the project management assistant.”””
print(“n” + “=”*60)
print(“PROJECT MARVEL ASSISTANT – PROCESSING MESSAGE”)
print(“=”*60)<\/p>\n
classification = triage_router(message_input)<\/p>\n
“classification”: classification,
“message_input”: message_input
}<\/p>\n
if classification == “respond”:
print(“n\ud83e\udd16 Generating response…”)
response = response_agent(message_input)
result[“response”] = response
print(f”n\ud83d\udcdd Generated Response: {response}”)<\/p>\n
“author”: “Sarah Chen <sarah.chen@company.com>”,
“to”: “John Martinez <john.martinez@company.com>”,
“subject”: “BLOCKER: API Integration Issue for Project Marvel”,
“message_thread”: “””Hi John,<\/p>\n
Sarah”””,
}<\/p>\n
{‘team_members’: [‘Sarah Chen’, ‘John Martinez’],
‘date’: ‘today’, ‘time’: ‘earliest_available’,
‘duration’: ’30 minutes’, ‘topic’:
‘Project Marvel: Debug API Integration Blocker (OAuth Flow)’}<\/p>\n
A sync meeting has been scheduled for today to debug the API Integration Blocker (OAuth Flow) with Sarah Chen and John Martinez. Please ensure both attend the scheduled meeting. I will also create a JIRA ticket to track this critical blocker.<\/p>\n
“author”: “Company Wide <announcements@company.com>”,
“to”: “All Employees <all@company.com>”,
“subject”: “Reminder: Health & Wellness Week Next Month”,
“message_thread”: “””Dear Team,<\/p>\n
– Yoga sessions
– Mental health workshops
– Free health screenings<\/p>\n
HR Team”””,
}<\/p>\nConclusion<\/h3>\n