> ## Documentation Index
> Fetch the complete documentation index at: https://docs.falkordb.com/llms.txt
> Use this file to discover all available pages before exploring further.
> ## Agent Instructions
> FalkorDB is a graph database that speaks the Redis protocol. Queries are issued as OpenCypher through the GRAPH.QUERY and GRAPH.RO_QUERY commands, not over Bolt or a SQL connection.
> FalkorDB implements a subset of OpenCypher with proprietary extensions. Do not assume Neo4j-only syntax or procedures are available — check /cypher/cypher-support and /cypher/known-limitations before using a clause.
> FalkorDB is the successor to RedisGraph, but they are separate products. Do not present RedisGraph commands, versions, or limitations as current FalkorDB behavior.
> Use the official clients listed in /getting-started/clients rather than generic Redis or Neo4j drivers, and prefer the language the user is already working in.
> Configuration parameters are set with GRAPH.CONFIG SET or at startup; cite the exact parameter name from /getting-started/configuration rather than inventing one.
> This site covers four products: FalkorDB (core), FalkorDB Cloud, FalkorDB Enterprise, and the GraphRAG SDK. Name which one an answer applies to, since setup and operations differ.
# FalkorDB
> Official FalkorDB documentation — the high-performance graph database for GraphRAG, Cypher queries, and knowledge graphs powering accurate GenAI applications.
## The graph platform developers use to achieve accurate GraphRAG for enterprise GenAI
FalkorDB delivers an **accurate, multi-tenant RAG solution powered by a low-latency, scalable graph database technology.** It is purpose-built for teams working with complex, interconnected data — structured or unstructured — in real-time and interactive environments, and it speaks [OpenCypher](https://www.opencypher.org/) with proprietary extensions that make graph traversal and querying practical in production.
Run FalkorDB locally, model your first graph, and query it in a few minutes.
FalkorDB is open source. A star helps other developers find the project.
Spin up a fully managed instance for free, with no local setup at all.
Ground your GenAI application in a knowledge graph with the GraphRAG SDK.
## Primary features
Nodes, relationships, labels, and properties, following the openCypher property graph model.
Declarative pattern matching, plus proprietary extensions layered on top of OpenCypher.
Combine [full-text search](/cypher/indexing/fulltext-index), [vector similarity](/cypher/indexing/vector-index), and [range indexing](/cypher/indexing/range-index) in one engine.
Connect over the [RESP](https://redis.io/docs/reference/protocol-spec/) protocol or over Bolt, whichever your stack already speaks.
Graphs are held as sparse adjacency matrices for compact storage and fast traversal.
Turn unstructured sources into a knowledge graph and query it from your GenAI app.
## 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.
## Community and support
Star the repository to follow releases and help other developers discover the project.
Ask questions and share what you are building with the team and the community.
Propose ideas, report rough edges, and search past answers on the FalkorDB forum.
## 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.
