A library inside one LangGraph process, or a memory service every agent can share

LangMem is LangChain's MIT-licensed memory library: tools and a background manager that live in your LangGraph application. Dakera is a server that any agent, in any language, connects to. Here is the same job written both ways.

Reviewed October 2026

The same memory, in code

Left, the LangMem quickstart from its documentation: two memory tools handed to a LangGraph agent, with memories in a LangGraph store. Right, Dakera behind the same kind of LangChain agent through langchain-dakera 0.3.0.

from langgraph.prebuilt import (
    create_react_agent,
)
from langgraph.store.memory import (
    InMemoryStore,
)
from langmem import (
    create_manage_memory_tool,
    create_search_memory_tool,
)

store = InMemoryStore(index={
    "dims": 1536,
    "embed":
        "openai:text-embedding-3-small",
})
agent = create_react_agent(
    "anthropic:claude-3-5-sonnet-latest",
    tools=[
        create_manage_memory_tool(
            namespace=("memories",)),
        create_search_memory_tool(
            namespace=("memories",)),
    ],
    store=store,
)

from langchain_dakera import DakeraMemory

memory = DakeraMemory(
    api_url="http://localhost:3000",
    api_key="dk-mykey",
    agent_id="my-agent",
    recall_k=5,
)

# Store a turn
memory.save_context(
    {"input": "I'm building a chatbot."},
    {"output": "Nice to meet you."},
)

# Recall, even after a restart
ctx = memory.load_memory_variables(
    {"input": "What was I building?"}
)
print(ctx["history"])

Where the memory lives

Then read it from anywhere

A memory service stops being tied to the process that wrote it. A Python worker stores a fact, and a TypeScript front end, a Go service or Claude (through the MCP server) recalls it.

from dakera import DakeraClient

client = DakeraClient(
    "http://localhost:3000",
    api_key="dk-mykey",
)
client.store_memory(
    agent_id="my-agent",
    content="User is learning Rust",
    importance=0.8,
)

import {
  DakeraClient,
} from '@dakera-ai/dakera';

const client = new DakeraClient({
  baseUrl: 'http://localhost:3000',
  apiKey: 'dk-mykey',
});
const { memories } = await client.recall(
  'my-agent', 'what is the user learning?',
  { top_k: 5 },
);
memories.forEach(m =>
  console.log(m.content));

What a shared service adds in v0.12.0

• Isolation. Namespaces, scoped API keys pinned to them, and namespace quotas that are enforced.
• Retrieval beyond one embedding. Hybrid BM25 and vector search, RRF fusion and a cross-encoder reranker, with multilingual embeddings across 100+ languages and full-text stemming in 18.
• Protection. AES-256-GCM at rest once a key is configured, per-namespace rotation, encrypted backups and authenticated, rate-limited gRPC for vector operations.
• Lifecycle. Six decay curves, TTL, forget, deduplication and consolidation, so memory stays relevant without a custom job.
• Availability. Multi-node high availability with replicated writes, /health/ready probes and Prometheus alert rules with a Grafana dashboard.
• Existing data. Dakera imports JSONL, CSV, Mem0 and Zep exports.

When to choose each

Prefer managed? Dakera Cloud is coming. Join the waitlist.

Frequently asked questions

Related comparisons: vs Letta · vs Mem0 · vs Zep