FalkorDB vs Neo4jWhich Graph Database for Agent Memory

Last tested: October 2026, FalkorDB 6.0, Neo4j 2026.09, graphiti-core 0.30.

Most FalkorDB vs Neo4j comparisons argue about query speed. For agent memory, speed rarely decides it. Three other questions do: what the license lets you do, how tenants are separated, and which database your team can already operate at 3 a.m.

TL;DR: FalkorDB vs Neo4j, which one?

Choose FalkorDB for agent memory and GraphRAG where each user, client or project needs its own graph on one small instance; it is the default backend of the Graphiti MCP server. Choose Neo4j when you need clustering, role-based access, graph data science, or a team that already knows its tooling. Read both licenses before you resell either.

Recommended path: FalkorDB for per-tenant agent memory

Agent memory is usually many small graphs, one per user, client or project. FalkorDB was built for that shape. Each graph is a separate key on the instance, and Graphiti on FalkorDB stores every group_id as its own graph. Deleting a client means deleting one graph, not hunting for nodes with the right property.

Start it with one container:

docker run -d --name falkordb \
  -p 6379:6379 -p 3000:3000 \
  -v ./falkordb-data:/var/lib/falkordb/data \
  falkordb/falkordb

Then point Graphiti at it. The database argument names the graph:

from graphiti_core import Graphiti
from graphiti_core.driver.falkordb_driver import FalkorDriver

driver = FalkorDriver(host="localhost", port=6379, database="acme")
graphiti = Graphiti(graph_driver=driver)
await graphiti.build_indices_and_constraints()

The browser UI on port 3000 shows the graph. Any Redis client can query it.

When Neo4j is the better call

Neo4j earns its place when the graph is shared infrastructure rather than per-agent memory:

• You already run it. Backups, monitoring and on-call already exist. A second graph database doubles that work.
• You need Enterprise features. Clustering, multiple databases and fine-grained access control live in Enterprise or Aura.
• You do graph analytics. The Graph Data Science library and the visual tooling around Neo4j have no equal on FalkorDB.
• Your Cypher uses plugins. Queries built on APOC procedures run only on Neo4j.

docker run -d --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/change-me-please \
  -v ./neo4j-data:/data \
  neo4j:latest   # pin a calendar version in production

from graphiti_core import Graphiti

graphiti = Graphiti("bolt://localhost:7687", "neo4j", "change-me-please")
await graphiti.build_indices_and_constraints()

On Community Edition every tenant shares one database, and separation is a group_id property filter on each query. That works, but a missed filter leaks one client’s facts into another’s answer.

The licensing question legal will ask

FalkorDB uses the SSPL. Running it behind your own application is the common case. The license targets offering the database’s functionality as a service to others; if your product exposes graph queries to customers, have legal read section 13 before launch.

Neo4j Community is GPLv3. Network use does not trigger its copyleft, but shipping Neo4j inside software you distribute does. Clustering and multiple databases need an Enterprise license or Aura.

Neither paragraph is legal advice. Both are the questions a DACH procurement team will raise, so answer them before the architecture review, not after.

Same Cypher, different dialects

Graphiti writes the same schema to both backends: Entity nodes, RELATES_TO edges carrying fact, valid_at and invalid_at. This query returns the currently valid facts on either database:

MATCH (a:Entity)-[r:RELATES_TO]->(b:Entity)
WHERE r.invalid_at IS NULL
RETURN a.name, r.fact, b.name
LIMIT 10

Run it on FalkorDB through any Redis client, and on Neo4j through cypher-shell:

redis-cli GRAPH.QUERY acme "MATCH (a:Entity)-[r:RELATES_TO]->(b:Entity) WHERE r.invalid_at IS NULL RETURN a.name, r.fact, b.name LIMIT 10"

cypher-shell -u neo4j -p change-me-please \
  "MATCH (a:Entity)-[r:RELATES_TO]->(b:Entity) WHERE r.invalid_at IS NULL RETURN a.name, r.fact, b.name LIMIT 10;"

Plain MATCH, WHERE and RETURN carry over. Procedures, some functions and admin commands do not. Grep your code for apoc. and CALL db. before you plan a switch.

Benchmark on your own graph before you trust a chart

Vendor benchmarks measure the vendor’s workload. Agent memory search is an embedding call plus a hybrid query, and the embedding call can take longer than the database. Load the same 1,000 episodes into both backends through Graphiti and time your real questions:

import statistics
import time

async def bench(graphiti, questions, group_ids):
    ms = []
    for q in questions:
        start = time.perf_counter()
        await graphiti.search(q, group_ids=group_ids)
        ms.append((time.perf_counter() - start) * 1000)
    ms.sort()
    return {"p50": statistics.median(ms), "p95": ms[int(len(ms) * 0.95) - 1]}

If the p95 difference is smaller than your embedding latency, pick on licensing and operations, not speed.

Choosing the backend is the first decision of a memory layer, not the last. If your team is weighing this for a production agent, it is the first hour of a knowledge graph consulting engagement.

Changelog

• 2026-10-12: First version, against FalkorDB 6.0, Neo4j 2026.09 and the Graphiti FalkorDB driver, with the license and tenant-separation comparison.