agent-memory

Neo4j Labs' graph-native agent memory: conversations, a POLE+O entity knowledge graph and reasoning traces in one store, with a 16-tool MCP server and hosted or self-hosted backends.

478 94 Python Apache-2.0updated 2 days ago

memory knowledge-graphs

View on GitHubDispute this mapping →

Curator's take

The pick when memory has to be queryable as a graph instead of a black box: entities resolve and dedupe, reasoning steps get explicit :TOUCHED audit edges to the entities they used, and you can adopt an existing Neo4j graph as long-term memory rather than re-ingesting. Multi-tenant scoping, buffered writes, consolidation primitives and an eval harness are already in the box, and the hosted NAMS tier lets you start with no database to run. Caveats: Neo4j Labs marks it Experimental and community-supported; extraction stacks spaCy/GLiNER/GLiREL plus an LLM pass, so ingest costs real time and tokens; and if you don't want a graph database in the stack at all, a Postgres- or file-backed layer is far less machinery.

Mapped by ShipWithAI editors · links verified

README.md

Neo4j Agent Memory

A graph-native memory system for AI agents. Store conversations, build knowledge graphs, and let your agents learn from their own reasoning -- all backed by Neo4j.

What It Does

The Neo4j Agent Memory data model

Short-Term Memory	Long-Term Memory	Reasoning Memory
Conversations & messages	Entities, preferences, facts	Reasoning traces & tool usage
Per-session history	Knowledge graph (POLE+O model)	Learn from past decisions
Vector + text search	Entity resolution & dedup	Similar task retrieval

The Neo4j Agent Memory entity extraction pipeline

Plus: multi-stage entity extraction (spaCy / GLiNER / LLM), relationship extraction (GLiREL), background enrichment (Wikipedia / Diffbot), geospatial queries, MCP server with 16 tools, and integrations with LangChain, Pydantic AI, Google ADK, Strands, CrewAI, and more.

Production features: adopt an existing Neo4j graph as long-term memory (client.schema.adopt_existing_graph(...)), multi-tenant scoping (user_identifier=), fire-and-forget buffered writes (client.buffered.submit(...)), consolidation primitives (client.consolidation.dedupe_entities(...)), an eval harness (client.eval.run(suite)), and explicit :TOUCHED audit edges from reasoning steps to entities.

Bring your own model: MemorySettings.embedding and MemorySettings.llm accept a provider-string shorthand ("anthropic/claude-3-5-sonnet-latest", "BAAI/bge-small-en-v1.5") or a Provider instance. Native adapters for OpenAI, Anthropic, Bedrock, Vertex AI, and sentence-transformers; LiteLLM universal fallback covers 100+ providers (Cohere, Voyage, Groq, Together, Mistral, Ollama, ...). See the provider migration guide. (These configure the self-hosted backend; on NAMS, embedding and extraction run server-side.)

SDKs

neo4j-labs/agent-memory ships two SDKs with the same memory model, both backed by the NAMS hosted service. Pick the one that matches your stack — mixed Python + TypeScript agents read and write the same memory.

Language	Package	Install	Docs
Python	`neo4j-agent-memory`	`pip install neo4j-agent-memory`	Python SDK docs
TypeScript	`@neo4j-labs/agent-memory`	`npm install @neo4j-labs/agent-memor

Continue your stack

What teams reach for next — and why each earns a place beside agent-memory. Ranked by curator confidence.

Pairs well with

LangGraph

Build stateful, multi-actor LLM apps as graphs — durable execution, human-in-the-loop, streaming.

Why it fitsShips first-class integrations for LangChain, Pydantic AI, CrewAI, Google ADK and Strands, so it slots in as durable memory behind a LangGraph app instead of hand-rolling checkpointer state into a knowledge graph.

Alternative to See all + compare →

MemMachine

Long-term memory layer for AI agents — episodic (graph), profile (SQL) and working memory behind Python/TS SDKs, REST and MCP; ships LangChain, LangGraph, CrewAI and LlamaIndex integrations.

Why it fitsBoth are drop-in long-term memory layers with framework adapters; MemMachine splits an episodic graph from a SQL profile store, while this keeps conversations, entities and reasoning in one Neo4j graph you can query in Cypher.

hindsight

Agent memory that learns, not just recalls: retain/recall/reflect API over Postgres, SOTA on LongMemEval. Self-host via Docker with UI; Python/TS clients, any LLM provider.

Why it fitsSame reflect-and-learn premise, different substrate: Hindsight runs on Postgres and benchmarks on LongMemEval; this trades that for a real graph with entity resolution and audit edges. Choose by whether you'd rather write Cypher or keep one Postgres dependency.

omnigraph

Lakehouse graph database for agent context — graph, vector and full-text retrieval fused in one runtime on branchable Lance/S3 storage; agent fleets write on isolated branches and merge Git-style.

Why it fitsBoth sell graph-native agent context. OmniGraph is a lakehouse engine with branchable Lance storage for agent fleets; Neo4j Agent Memory is an opinionated short-term/long-term/reasoning memory API on a database most teams already know.