Neo4j vs. Kuzu vs. Memgraph – which graph DB for which AI setup?

What this is about

Once a knowledge graph becomes serious, the DB question arrives. Three engines dominate 2026 for AI setups: Neo4j, Kuzu and Memgraph. They all speak Cypher (in dialects) but differ massively in deployment, performance profile, and licensing.

This article helps you pick — without drifting into Cypher micro-benchmarks.

The three profiles in one sentence

• Neo4j — the industry standard. Server-based, huge ecosystem, enterprise features. What you can defend in a CTO pitch without slides.
• Kuzu — embedded, columnar, extremely fast for batch analytics. "SQLite for graphs". The default for local RAG prototypes.
• Memgraph — server, in-memory, stream-native. When the graph changes many times per second (logs, sensors, trading).

Direct comparison

When which?

Neo4j

If you need production-ready in enterprise, Neo4j is almost always the default. Reasons:

• Every RAG framework has a Neo4j connector (LlamaIndex, LangChain, GraphRAG).
• Bloom, Neo4j Browser, Workspace — the tools for ontology workshops are mature.
• Multi-tenant, RBAC, backup, clustering — all there, you don't build it.
• AuraDB with an EU region for GDPR is out-of-the-box.

Trade-off: enterprise license isn't cheap, and for small setups (< 5M nodes) Neo4j is overkill.

Kuzu

If you think embedded — the graph should live in the same process as your app or notebook — Kuzu is unbeatable:

• One library, no separate server.
• Loads Parquet, CSV, JSON natively.
• Columnar storage → analytical queries (aggregation, path counts) fly.
• Perfect for local RAG tools, agent sandboxes, Jupyter workflows, edge deployments.

Trade-off: no multi-user access (file lock), smaller driver pool, fewer integrated tools.

Memgraph

If the graph lives — continuous updates from Kafka, webhooks, IoT — Memgraph is the specialist:

• In-memory with WAL → millisecond queries even under heavy writes.
• MAGE (module library) for graph algorithms on stream.
• Native Kafka integration.
• Stream-first use cases: fraud detection, network monitoring, real-time recommendations.

Trade-off: RAM scales directly with the graph. Smaller framework ecosystem than Neo4j.

AI-specific aspects

Vector index in the graph

All three now ship native vector indexes (HNSW). In practice: hybrid retrieval in a single query — subgraph traversal combined with semantic search, no separate vector DB. In 2024 that was still an argument for additional tools like Qdrant or Weaviate — today one engine is enough.

GraphRAG maturity

• Neo4j: Microsoft GraphRAG, LlamaIndex KG Index, LangChain — all support Neo4j first-class. Best docs and examples.
• Kuzu: LlamaIndex has an official Kuzu graph store, growing fast. Fastest pick for local prototypes.
• Memgraph: LlamaIndex support exists, fewer tutorials. The pick when you're coming from a streaming use case and want to add graph.

Cypher compatibility

All three speak openCypher in similar dialects. Good news: migration is feasible. Bad news: Neo4j's enterprise features (APOC, GDS library) are often the lock-in argument.

Decision tree

Need real-time updates (>10 writes/s, ms latency)?
  → yes → Memgraph
  → no
    │
    Should the graph run in the same process as your app?
      → yes → Kuzu
      → no
        │
        Need multi-tenant, enterprise backup, cluster?
          → yes → Neo4j (Aura or self-hosted Enterprise)
          → no  → Neo4j Community or Kuzu, depending on team experience

Our pragmatic default

• Prototype/notebook: Kuzu. Installed fast, gone fast.
• Production service with web UI / API: Neo4j Aura (EU region).
• Streaming/real time: Memgraph.
• Embedded in desktop app or edge: Kuzu, no discussion.

When a customer asks "which one?", the answer is almost always Neo4j — not because it's objectively superior, but because the ecosystem (tools, hires, docs) makes the difference once more than one person works on it.

Conclusion

"Which graph DB?" is rarely decided by Cypher syntax. It's decided by deployment model, read/write profile, and team experience. Three clear profiles, three clear default decisions — and in 80% of cases the choice is made in five minutes.

---

Related reading:

• What is a knowledge graph? – why graph at all
• GraphRAG vs. vector RAG – what the graph is for
• Entity extraction with LLMs – how it gets populated
• Knowledge graph as a service – when you don't want to set it up yourself