FalkorDB is a Rust-based, Redis-compatible graph database that stores graphs as sparse adjacency matrices and queries them with linear algebra, built for GraphRAG pipelines, agent memory, cloud security and fraud-detection workloads.

What it is

FalkorDB is a multi-tenant property graph database that uses GraphBLAS under the hood to represent the graph's adjacency matrix as a sparse matrix, then executes queries with linear algebra rather than conventional pointer-chasing traversal. The README states it is the first queryable property graph database to take this approach. It complies with the Property Graph Model, so nodes and relationships carry attributes, and it supports OpenCypher as its query language, including proprietary extensions for advanced querying. It is written in Rust, carries a NOASSERTION licence, has roughly 6,100 stars and 460 forks, and is documented at falkordb.com.

The practical problem it addresses is latency in knowledge-graph retrieval for Large Language Models. The project's stated goal is a high-performance knowledge graph tailored for LLMs, with exceptionally low latency for fast information delivery, which is what GraphRAG and agent-memory patterns depend on. It lives in the Redis ecosystem rather than beside it: FalkorDB accepts commands from any Redis client, so redis-cli and existing Redis tooling reach it directly on port 6379, and the browser interface runs on port 3000. For a team already running Redis, this replaces standing up a separate graph service with its own driver and wire protocol; graph work is issued through the same client the team already uses.

Key capabilities

• Sparse matrix representation of the adjacency matrix, via GraphBLAS, to optimise storage and performance.
• Linear algebra query execution, which the README presents as the mechanism behind its computational efficiency.
• Property Graph Model compliance, so nodes and relationships carry named attributes.
• OpenCypher support, plus proprietary extensions for advanced querying.
• Redis protocol compatibility: GRAPH.QUERY runs from redis-cli, for example GRAPH.QUERY social "CREATE (:person {name: 'roi', age: 33})".
• Multi-tenant graph selection through the client API, such as db.select_graph('MotoGP') or db.select_graph('social').
• Official client libraries across several languages, including the falkordb Python package, plus a bundled browser UI.

Who uses it and how

• Teams building GraphRAG retrieval layers over LLMs, where the knowledge graph must answer with low latency.
• Agent-memory implementations that persist and traverse relationship data between model calls.
• Cloud security and fraud-detection workloads, which the README names as target uses and which depend on connected-entity analysis.
• Multi-tenant AI applications and database-as-a-service offerings, reflected in the cloud-database, database-as-a-service and realtime-database topics.
• Existing Redis deployments that want queryable graph data reachable from redis-cli and their current clients, without adding a second database protocol.

Getting started

Launch an instance with Docker: docker run -p 6379:6379 -p 3000:3000 -it --rm -v ./data:/var/lib/falkordb/data falkordb/falkordb. Then open http://localhost:3000 in a browser, or connect with a supported client library such as Python's falkordb package.

How it compares

The facts do not name any paid products that FalkorDB replaces, and they name no equivalent graph database to measure it against. It stands alone in this registry on the evidence provided, so no licence, hosting or cost comparison can be drawn from the material supplied.

When to use it — and when not to

A self-hoster must operate the FalkorDB server itself, which in the documented path means running the falkordb/falkordb Docker image and persisting data to a mounted volume at /var/lib/falkordb/data, along with whatever hosting, backup and monitoring surrounds that container. The licence is recorded as NOASSERTION, so the actual terms are not declared by the metadata; anyone with strict licence-review requirements should resolve that before adopting it. It is also worth noting the repository carries 724 open issues, and the README does not document clustering, backup or upgrade procedures, so teams needing certified high-availability operations or relational SQL semantics should look elsewhere.

docker run -p 6379:6379 -p 3000:3000 -it --rm -v ./data:/var/lib/falkordb/data falkordb/falkordb

from falkordb import FalkorDB

# Connect to FalkorDB
db = FalkorDB(host='localhost', port=6379)

# Create the 'MotoGP' graph
g = db.select_graph('MotoGP')
g.query("""CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'}),
                  (:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'}),
                  (:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})""")

# Query which riders represents Yamaha?
res = g.query("""MATCH (r:Rider)-[:rides]->(t:Team)
                 WHERE t.name = 'Yamaha'
                 RETURN r.name""")

for row in res.result_set:
	print(row[0])

# Prints: "Valentino Rossi"

# Query how many riders represent team Ducati ?
res = g.query("""MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'})
                 RETURN count(r)""")

print(res.result_set[0][0])
# Prints: 1

$ redis-cli
127.0.0.1:6379> GRAPH.QUERY social "CREATE (:person {name: 'roi', age: 33, gender: 'male', status: 'married'})"

from falkordb import FalkorDB

# Connect to FalkorDB
db = FalkorDB(host='localhost', port=6379)

# Select the social graph
g = db.select_graph('social')

reply = g.query("CREATE (:person {name:'roi', age:33, gender:'male', status:'married'})")