How to Add Persistent Memory to Any LangChain Agent (5-Minute Integration)

# The naive approach — looks simple, breaks fast
user_sessions = {}

def get_agent_response(user_id: str, message: str):
    history = user_sessions.get(user_id, [])
    history.append({"role": "user", "content": message})

    # Dump the entire history into the context window
    context = "\n".join([f"{m['role']}: {m['content']}" for m in history])
    response = agent.run(f"{context}\n{message}")

    history.append({"role": "assistant", "content": response})
    user_sessions[user_id] = history
    return response

# Without Synap — agents forget everything
agent.run("What was my last order?")  # Agent has no idea

# With Synap — persistent memory across sessions
from synap import SynapClient

client = SynapClient(api_key="syn_your_key")
client.remember(user_id, "Last order: MacBook Pro, Jan 15")
memory = client.recall(user_id)
agent.run(f"Context: {memory}\nWhat was my last order?")  # Agent remembers!

pip install synap-memory langchain langchain-openai

from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from synap import SynapClient

client = SynapClient(api_key="syn_your_key")
llm = ChatOpenAI(model="gpt-4o", temperature=0)

@tool
def lookup_order(order_id: str) -> str:
    """Look up order details by order ID."""
    # Your order lookup logic here
    return f"Order {order_id}: MacBook Pro 14\", shipped Jan 15, delivered Jan 17"

def handle_support_message(user_id: str, message: str) -> str:
    # 1. Recall relevant memories for this user
    memories = client.recall(user_id, query=message)

    # 2. Build context-aware system prompt
    system_prompt = f"""You are a helpful customer support agent.

User context from previous sessions:
{memories if memories else "No previous context for this user."}

Use this context to provide personalized support. Don't ask for information
the user has already provided in past sessions."""

    # 3. Run the agent with injected memory
    agent = create_openai_functions_agent(llm, [lookup_order], system_prompt)
    executor = AgentExecutor(agent=agent, tools=[lookup_order])
    response = executor.invoke({"input": message})["output"]

    # 4. Remember this interaction for future sessions
    client.remember(user_id, f"User asked: {message[:200]}. Agent responded: {response[:200]}")

    return response


# Session 1 — User provides context
handle_support_message("user_123", "Hi! I prefer email updates, not SMS.")
handle_support_message("user_123", "My email is alice@example.com")
handle_support_message("user_123", "I just placed order #A8821 for a laptop.")

# --- Days later, new session ---

# Session 2 — Agent already knows the user
response = handle_support_message("user_123", "Where's my laptop?")
# Agent knows: email preference, email address, order #A8821
# No re-explaining needed. Pure continuity.
print(response)

from synap.langchain import SynapMemory
from langchain.chains import ConversationChain

# Drop-in replacement for ConversationBufferMemory
memory = SynapMemory(api_key="syn_your_key", agent_id="support-agent-user_123")

chain = ConversationChain(llm=llm, memory=memory)

# Session 1
chain.predict(input="I prefer email updates over SMS.")

# Restart your server, start a new process...

# Session 2 — memory is loaded from Synap automatically
chain.predict(input="How do you normally contact me?")
# > "Based on your preference, I'd use email to contact you."