langgraph-memory

A long-term memory engine for LangGraph over any BaseStore: LLM fact extraction, consolidation against what is already known, and recall ranked by semantic similarity, recency and importance. A maintained alternative to LangMem (dormant since late 2025), modelled on CrewAI's unified Memory engine and built to pair with the agentstate-reducer on_prune hook and the langgraph-store-* backends.

pip install langgraph-memory

from langgraph_memory import MemoryEngine
from langgraph_store_postgres import PostgresStore
from langgraph_store_core import bedrock_titan_embeddings

store = PostgresStore(url, index={"dims": 1024, "embed": bedrock_titan_embeddings(dimensions=1024), "fields": ["content"]})
engine = MemoryEngine(store, "anthropic:claude-sonnet-5")

engine.remember(messages, namespace=("memories", "kamal"))                 # extract → dedupe → consolidate → put
for m in engine.recall("what does the user prefer for travel?", namespace=("memories", "kamal"), limit=5):
    print(m.score, m.record.content, m.match_reasons)

What it does

All weights, the half-life, thresholds and oversampling live in MemoryConfig.

Choosing the model

There is no default model — pass one explicitly. A memory engine that silently spends tokens on every prune would be a bad surprise, and the rest of the toolkit avoids picking a vendor for you. The embedding model is separate: it lives on the store's IndexConfig.

The same model serves both LLM steps, extraction and the consolidation decision, and both use with_structured_output, so the model must support tool calling or JSON-schema output (current Anthropic, OpenAI, Bedrock Converse and Gemini chat models all do). The system prompts are overridable: LLMExtractor(model, prompt=...) and LLMConsolidator(model, prompt=...), passed as extractor= / consolidator=, let you steer what counts as worth remembering for your domain without touching the pipeline.

Integrations

from agentstate_reducer import MessageReducer, ReducerConfig, Background
reducer = MessageReducer(config=ReducerConfig(max_messages=20, on_prune=[Background(engine.on_prune)]))
saver = DynamoDBSaver("checkpoints", reducer=reducer)      # pruned turns become memories, under memory_namespace

agent = create_react_agent(model, tools=engine.tools())     # search_memory / manage_memory, namespace from config["configurable"]["memory_namespace"]
graph.add_node("recall", engine.recall_node(into="memory", limit=5))   # writes formatted memories into state["memory"] before the model call

engine.forget(namespace, key=... | categories=... | older_than=...) and engine.list(namespace) for housekeeping; aremember / arecall for async graphs.

Embedding

The engine never embeds anything. The store does, on put and on search(query=...), using the IndexConfig it was built with — so one embedder serves writes, consolidation lookups and recall, and each backend uses its native vector engine (DynamoDB SearchVectors, pgvector, Cosmos VectorDistance, Firestore find_nearest). The constructor refuses a store without an IndexConfig, because recall could not rank on it. Dimensions are fixed at index creation on every backend; changing the embedding model means a new table and re-embedding.

Testing

Deterministic and offline: LangGraph's InMemoryStore with langgraph_store_core.testing.FakeEmbeddings, and rule-based extractor/consolidator callables instead of a model. Backend e2e tests run the same suite against langgraph-store-postgres (pgvector) and langgraph-store-dynamodb, plus a real DynamoDBSaver + reducer on_prune flow.

Docs: https://skamalj.github.io/agentstate-reducer/

License

MIT