LangChain Persistent Memory with Dakera

The Problem with LangChain's Built-in Memory

LangChain's memory classes (ConversationBufferMemory, ConversationSummaryMemory, VectorStoreRetrieverMemory) have fundamental limitations:

• Ephemeral — stored in process memory, lost on restart
• No cross-session recall — each conversation starts from scratch
• No temporal reasoning — cannot answer "What did the user say last week?"
• No knowledge graphs — cannot track entity relationships
• No decay — buffers grow unbounded or truncate arbitrarily

How It Works

pip install dakera langchain

Code Example: LangChain + Dakera

from dakera import Dakera
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Initialize Dakera
memory = Dakera(base_url="http://localhost:3300", api_key="dk-...")
llm = ChatOpenAI(model="gpt-4o")

def chat_with_memory(user_input: str, user_id: str) -> str:
    # 1. Recall relevant memories
    memories = memory.memory.recall(
        query=user_input,
        namespace=user_id,
        top_k=5
    )

    context = "\n".join([m["content"] for m in memories["results"]])

    # 2. Build prompt with memory context
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful assistant. Use this memory context:\n{context}"),
        ("human", "{input}")
    ])

    chain = prompt | llm | StrOutputParser()
    response = chain.invoke({"context": context, "input": user_input})

    # 3. Store the interaction as a new memory
    memory.memory.store(
        content=f"User said: {user_input}\nAssistant responded: {response}",
        namespace=user_id,
        metadata={"source": "langchain", "type": "conversation"}
    )

    return response

What You Gain Over Built-in Memory

Works with LangGraph Too

from langgraph.graph import StateGraph
from dakera import Dakera

memory = Dakera(base_url="http://localhost:3300", api_key="dk-...")

def recall_node(state):
    """Inject relevant memories into agent state."""
    memories = memory.memory.recall(
        query=state["input"],
        namespace=state["user_id"],
        top_k=5
    )
    state["context"] = memories["results"]
    return state

def store_node(state):
    """Persist the agent's output as a memory."""
    memory.memory.store(
        content=state["output"],
        namespace=state["user_id"],
        metadata={"agent": state["agent_name"]}
    )
    return state

# Add recall_node before your LLM node, store_node after
graph = StateGraph(...)
graph.add_node("recall", recall_node)
graph.add_node("store", store_node)