Using Dakera with LangChain for persistent agent memory

[ferhimedamine]

Overview

I wanted to share how we use Dakera as the persistent memory backend for LangChain agents. The key challenge: LangChain’s built-in ConversationBufferMemory is ephemeral — every restart loses context. With dakera-langchain, memories survive restarts, scale across sessions, and decay gracefully so agents don’t get overwhelmed by stale context.

Installation

pip install dakera langchain-core
# Clone and install the integration
git clone https://github.com/dakera-ai/dakera-deploy
cd dakera-deploy/docker && docker compose -f docker-compose.local.yml up -d

Code example

from dakera import DakeraClient
from dakera.langchain import DakeraMemory

# Connect to your Dakera instance
memory = DakeraMemory(
    api_url="http://localhost:3000",
    agent_id="my-langchain-agent",
    recall_k=5,          # top-5 semantically relevant memories
    importance=0.7,      # how strongly this memory is retained
    memory_type="episodic",
    tags=["langchain", "customer-service"],
)

# Use it in any LangChain chain
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

chain = ConversationChain(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    memory=memory,
)

# First conversation
chain.invoke({"input": "My name is Alex and I prefer concise answers."})

# Restart your process. Memory persists.
chain.invoke({"input": "What do you know about my preferences?"})
# → "You prefer concise answers, Alex."

Session grouping

For multi-user or multi-conversation setups, you can group memories by session:

from dakera import DakeraClient

client = DakeraClient("http://localhost:3000")

# Start a session
session = client.start_session("my-langchain-agent", metadata={"user": "alex"})
session_id = session["id"]

# Store memories scoped to this session
client.store(
    agent_id="my-langchain-agent",
    content="User is debugging a React render loop issue",
    importance=0.8,
    session_id=session_id,
    tags=["debug", "react"],
)

# Recall only within this session
memories = client.recall(
    agent_id="my-langchain-agent",
    query="What was the user working on?",
    session_id=session_id,
)

client.end_session(session_id, summary="Resolved React render loop")

Why importance scoring matters

Each memory gets an importance value (0.0–1.0). Dakera applies time-based decay, so low-importance memories fade over time while high-importance ones (user preferences, key facts) persist. This means your agent’s context stays relevant without manual cleanup.

Self-hosting

All of this runs on a single Docker container with zero external dependencies:

docker compose -f docker/docker-compose.local.yml up -d

No cloud account needed, no external vector database, no separate embedding service.

---

Happy to answer questions about the integration pattern! What use cases are you building with persistent agent memory?