A scalable, low-latency graph database designed for development teams managing structured and unstructured interconnected data in real-time or interactive environments.

Our goal is to build a high-performance Knowledge Graph tailored for Large Language Models (LLMs), prioritizing exceptionally low latency to ensure fast and efficient information delivery through our Graph Database.

🆕 FalkorDB is the first queryable Property Graph database to leverage sparse matrices for representing the adjacency matrix in graphs and linear algebra for querying.

• Sparse Matrix Representation: Utilizes sparse matrices to represent adjacency matrices, optimizing storage and performance.

• Linear Algebra Querying: Employs linear algebra for query execution, enhancing computational efficiency.

• Property Graph Model Compliance: Supports nodes and relationships with attributes, adhering to the Property Graph Model.

• OpenCypher Support: Compatible with OpenCypher query language, including proprietary extensions for advanced querying capabilities.

Explore FalkorDB in action by visiting the Demos.

Official Docs | Clients | Commands | 📊 Latest Performance Benchmarks

• Discussions: Join our community discussions on GitHub Discussions to ask questions, share ideas, and connect with other users.

• Contributing: We welcome contributions! Please see our Contributing Guide for more details.

• License: This project is licensed under the Server Side Public License v1 (SSPLv1). See the LICENSE file for details.

To quickly try out FalkorDB, launch an instance using docker:

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

Or, to use the built-in browser-based interface, run:

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

Then, open your browser and navigate to http://localhost:3000.

You can also interact with FalkorDB using any of the supported Client Libraries

In this example, we'll use the FalkorDB Python client to create a small graph representing a subset of motorcycle riders and teams participating in the MotoGP league. After creating the graph, we'll query the data to explore its structure and relationships.

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

Make sure to complete these requirements:

1️⃣ The FalkorDB repository: git clone --recurse-submodules -j8 https://github.com/FalkorDB/FalkorDB.git

On Ubuntu Linux, run: apt-get install build-essential cmake m4 automake peg libtool autoconf python3 python3-pip

On OS X, verify that homebrew is installed and run: brew install cmake m4 automake peg libtool autoconf.

The version of Clang that ships with the OS X toolchain does not support OpenMP, which is a requirement for FalkorDB. One way to resolve this is to run brew install gcc g++ and follow the on-screen instructions to update the symbolic links. Note that this is a system-wide change - setting the environment variables for CC and CXX will work if that is not an option.

2️⃣ Build by running make in the project's directory.

Congratulations! You can find the compiled binary at bin/<arch>/src/falkordb.so.

Start by installing the required Python packages by running pip install -r requirements.txt from the tests directory.

Note: If you've got redis-server in PATH, just invoke make test. Otherwise, invoke REDIS_SERVER=<redis-server-location> make test. For a more verbose output, run make test V=1.

The FalkorDB build system runs within docker. For detailed instructions on building, please see here.

FalkorDB is hosted by Redis, so you'll first have to load it as a Module to a Redis server.

Note: Redis 6.2 is required for FalkorDB 2.12.

💡 We recommend having Redis load FalkorDB during startup by adding the following to your redis.conf file:

loadmodule /path/to/module/src/falkordb.so

In the line above, replace /path/to/module/src/falkordb.so with the actual path to FalkorDB's library. If Redis is running as a service, you must ensure that the redis user (default) has the necessary file/folder permissions to access falkordb.so.

Alternatively, you can have Redis load FalkorDB using the following command line argument syntax:

~/$ redis-server --loadmodule /path/to/module/src/falkordb.so

Lastly, you can also use the MODULE LOAD command. Note, however, that MODULE LOAD is a dangerous command and may be blocked/deprecated in the future due to security considerations.

Once you've successfully loaded FalkorDB your Redis log should see lines similar to:

...
30707:M 20 Jun 02:08:12.314 * Module 'graph' loaded from <redacted>/src/falkordb.so
...

If the server fails to launch with output similar to:

# Module /usr/lib/redis/modules/falkordb.so failed to load: libgomp.so.1: cannot open shared object file: No such file or directory
# Can't load module from /usr/lib/redis/modules/falkordb.so: server aborting

The system is missing the run-time dependency OpenMP. This can be installed on Ubuntu with apt-get install libgomp1, on RHEL/CentOS with yum install libgomp, and on OSX with brew install libomp.

You can call FalkorDB's commands from any Redis client. Here are several methods:

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

You can interact with FalkorDB using your client's ability to send raw Redis commands.

Note: Depending on your client of choice, the exact method for doing that may vary.

This code snippet shows how to use FalkorDB with from Python using falkordb-py:

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'})")

Note: Some languages have client libraries that provide support for FalkorDB's commands:

Project	Language	License	Author	Stars	Package	Comment
jfalkordb	Java	BSD	FalkorDB		Maven
falkordb-py	Python	MIT	FalkorDB		pypi
falkordb-ts	Node.JS	MIT	FalkorDB		npm
falkordb-rs	Rust	MIT	FalkorDB		Crate
falkordb-go	Go	BSD	FalkorDB		GitHub
NFalkorDB	C#	Apache-2.0	FalkorDB		nuget

Project	Language	License	Author	Stars	Package	Comment
nredisstack	.NET	MIT	Redis		nuget
redisgraph-rb	Ruby	BSD	Redis		GitHub
redgraph	Ruby	MIT	pzac		GitHub
redisgraph-go	Go	BSD	Redis		GitHub
rueidis	Go	Apache 2.0	Rueian		GitHub
ioredisgraph	JavaScript	ISC	Jonah		GitHub
@hydre/rgraph	JavaScript	MIT	Sceat		GitHub
php-redis-graph	PHP	MIT	KJDev		GitHub
redisgraph_php	PHP	MIT	jpbourbon		GitHub
redisgraph-ex	Elixir	MIT	crflynn		GitHub
redisgraph-rs	Rust	MIT	malte-v		GitHub
redis_graph	Rust	BSD	tompro		GitHub
rustis	Rust	MIT	Dahomey Technologies		Crate	Documentation
NRedisGraph	C#	BSD	tombatron		GitHub
RedisGraph.jl	Julia	MIT	xyxel		GitHub

Licensed under the Server Side Public License v1 (SSPLv1). See LICENSE.

⭐️ If you find this repository helpful, please consider giving it a star!

↗️ Graph, graph database, RAG, graphrag, Retrieval-Augmented Generation,Information Retrieval, Natural Language Processing, LLM, Embeddings, Semantic Search