> ## Documentation Index
> Fetch the complete documentation index at: https://new.docs.falkordb.com/llms.txt
> Use this file to discover all available pages before exploring further.
# FalkorDB
> Official FalkorDB documentation — the high-performance graph database for GraphRAG, Cypher queries, and knowledge graphs powering accurate GenAI applications.
[](https://trendshift.io/repositories/14787)
[](https://hub.docker.com/r/falkordb/falkordb/)
[](https://discord.gg/6M4QwDXn2w)
[](https://app.falkordb.cloud)
## The Graph platform developers use to achieve accurate GraphRAG for enterprise GenAI
## About FalkorDB
FalkorDB delivers an **accurate, multi-tenant RAG solution powered by a low-latency, scalable graph database technology.**
* Purpose-built for development teams working with complex, interconnected data—whether structured or unstructured—in real-time or interactive user environments.
* Supports the OpenCypher query language with proprietary enhancements that streamline interactions with graph data. Its efficient graph traversal and query capabilities make it well-suited for production environments.
## Choose Your Path
* **Graph Database Path:** If you're interested in using FalkorDB as a property graph database with OpenCypher support, continue with the sections below.
* **GraphRAG Path:** If you're aiming to implement advanced graph reasoning and generative AI tasks, explore our [GenAI Tools](/genai-tools) section, starting with the [GraphRAG SDK](/genai-tools/graphrag-sdk).
## Primary Features
* Adopts the [Property Graph Model](https://github.com/opencypher/openCypher/blob/master/docs/property-graph-model.adoc)
* Supports [OpenCypher](https://www.opencypher.org/) query language with proprietary extensions
* Offers [Full-Text Search](/cypher/indexing/fulltext-index), [Vector Similarity](/cypher/indexing/vector-index), and [Range indexing](/cypher/indexing/range-index) for efficient querying
* Supports both [RESP](https://redis.io/docs/reference/protocol-spec/) and [Bolt](https://en.wikipedia.org/wiki/Bolt_\(network_protocol\)) protocols for flexible connectivity
* Uses sparse adjacency matrix representation for efficient graph storage
* Provides GraphRAG capabilities through the [GraphRAG SDK](/genai-tools/graphrag-sdk) for advanced graph reasoning and generative AI tasks
## Get Started
Launch an instance using Docker, or use [FalkorDB Cloud](https://app.falkordb.cloud)
```sh theme={null}
docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
```
### Ports Exposed
* **6379 (FalkorDB Server)**\
Use this port to connect via the CLI or any FalkorDB-compatible client.
* **3000 (FalkorDB Browser)**\
Access the FalkorDB web UI by opening your browser at: [http://localhost:3000](http://localhost:3000)
Once loaded, you can interact with FalkorDB using any of the supported [client libraries](/getting-started/clients)
> **📖 New to FalkorDB?** Follow the step-by-step [Getting Started guide](/getting-started) for a complete walkthrough — from setup to modeling, loading, and querying your first graph.
Here we'll use [FalkorDB Python client](https://pypi.org/project/FalkorDB/) to create a small graph representing a subset of motorcycle riders and teams taking part in the MotoGP league, once created we'll start querying our data.
```python Python theme={null}
from falkordb import FalkorDB
# Connect to FalkorDB
db = FalkorDB(host='localhost', port=6379)
# Create the 'MotoGP' graph
g = db.select_graph('MotoGP')
# Clear out this graph in case you've run this script before.
g.delete()
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 represent 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
```
```javascript JavaScript theme={null}
import { FalkorDB } from 'falkordb';
const db = await FalkorDB.connect({
// username: 'myUsername',
// password: 'myPassword',
socket: {
host: 'localhost',
port: 6379
}
})
console.log('Connected to FalkorDB')
const graph = db.selectGraph('MotoGP')
await graph.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'})`)
const result = await graph.query(`MATCH (r:Rider)-[:rides]->(t:Team)
WHERE t.name = $name RETURN r.name`,
{params: {name: 'Yamaha'}})
console.log(result) // Valentino Rossi
console.log(await db.list())
console.log(await db.info())
db.close()
```
```java Java theme={null}
package com.falkordb;
import com.falkordb.*;
import java.util.*;
public class FalkorDBExample {
public static void main(String[] args) {
// Connect to FalkorDB
Driver driver = FalkorDB.driver("localhost", 6379);
// Select the graph
Graph graph = driver.graph("MotoGP");
// Create graph data
graph.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 with parameters
Map params = new HashMap<>();
params.put("name", "Yamaha");
ResultSet resultSet = graph.query(
"MATCH (r:Rider)-[:rides]->(t:Team) " +
"WHERE t.name = $name RETURN r.name", params);
// Process query results
for (Record record : resultSet) {
String riderName = record.getValue("r.name").toString();
System.out.println(riderName); // Valentino Rossi
}
// Close the connection
driver.close();
}
}
```
```rust Rust theme={null}
use falkordb::{FalkorClientBuilder, FalkorConnectionInfo};
#[tokio::main]
async fn main() -> Result<(), Box> {
// Connect to FalkorDB
let connection_info: FalkorConnectionInfo = "falkor://127.0.0.1:6379"
.try_into()
.expect("Invalid connection info");
let client = FalkorClientBuilder::new_async()
.with_connection_info(connection_info)
.build()
.await?;
// Select the 'MotoGP' graph
let mut graph = client.select_graph("MotoGP");
// Clear out this graph in case you've run this script before.
graph.delete().await?;
graph
.query(
r#"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'})"#,
)
.execute()
.await?;
// Query which riders represent Yamaha?
let mut nodes = graph
.query(
r#"MATCH (r:Rider)-[:rides]->(t:Team)
WHERE t.name = 'Yamaha'
RETURN r.name"#,
)
.execute()
.await?;
for node in nodes.data.by_ref() {
println!("{:?}", node);
}
// Query how many riders represent team Ducati?
let mut nodes = graph
.query(r#"MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'}) RETURN count(r)"#)
.execute()
.await?;
for node in nodes.data.by_ref() {
println!("{:?}", node);
}
Ok(())
}
```
```bash Shell theme={null}
$ redis-cli -h localhost -p 6379
127.0.0.1:6379> GRAPH.QUERY MotoGP "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'})"
1) 1) "Labels added: 2"
2) "Nodes created: 6"
3) "Properties set: 6"
4) "Relationships created: 3"
5) "Cached execution: 0"
6) "Query internal execution time: 9.155705 milliseconds"
127.0.0.1:6379> GRAPH.QUERY MotoGP "MATCH (r:Rider)-[:rides]->(t:Team) WHERE t.name = 'Yamaha' RETURN r.name"
1) 1) "r.name"
2) 1) 1) "Valentino Rossi"
3) 1) "Cached execution: 0"
2) "Query internal execution time: 5.389149 milliseconds"
127.0.0.1:6379> GRAPH.QUERY MotoGP "MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'}) RETURN count(r)"
1) 1) "count(r)"
2) 1) 1) (integer) 1
3) 1) "Cached execution: 0"
2) "Query internal execution time: 1.153678 milliseconds"
```
For additional demos please visit [Demos](https://github.com/FalkorDB/demos).
## Client libraries
Language-specific clients have been written by the community and the FalkorDB team.
The full list and links can be found on the [Client Libraries](/getting-started/clients) page.
## Data import
When loading large graphs from CSV files, use the [falkordb-bulk-loader](https://github.com/falkordb/falkordb-bulk-loader):
```sh theme={null}
pip install falkordb-bulk-loader
falkordb-bulk-insert GRAPHNAME -n nodes.csv -r edges.csv
```
See the [Bulk Loader documentation](/integration/bulk-loader) for the full reference.
## GitHub Discussions
Got questions? Please contact us at the [FalkorDB forum](https://github.com/FalkorDB/FalkorDB/discussions).
## License
FalkorDB is licensed under the [the Server Side Public License v1 (SSPLv1)](https://github.com/FalkorDB/FalkorDB/blob/master/LICENSE.txt).
## Frequently Asked Questions
FalkorDB is a high-performance graph database built as a Redis module. Unlike traditional graph databases, it uses a sparse adjacency matrix representation (based on GraphBLAS) for efficient storage and fast traversals. It supports **OpenCypher** queries, both RESP and Bolt protocols, and provides built-in GraphRAG capabilities for GenAI applications.
FalkorDB excels at use cases involving complex, interconnected data: social networks, recommendation engines, knowledge graphs, fraud detection, and **GraphRAG for GenAI applications**. Its low-latency design makes it ideal for real-time and interactive user environments.
The quickest way is Docker: `docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest`. This starts the server and a browser UI at [http://localhost:3000](http://localhost:3000). Then install a [client library](/getting-started/clients) and follow the [Getting Started guide](/getting-started).
Yes. [FalkorDB Cloud](https://app.falkordb.cloud) provides a fully managed, multi-tenant graph database service. You can create a free instance and skip local setup entirely.
FalkorDB uses **OpenCypher** with proprietary extensions. It supports full-text search, vector similarity search, and range indexing. See the [Cypher documentation](/cypher) for the complete query language reference.