| layout | title | nav_order | description | permalink |
|---|---|---|---|---|
default |
Home |
1 |
The fastest way to your knowledge |
/ |
FalkorDB delivers an accurate, multi-tenant RAG solution powered by a low-latency, scalable graph database technology.
-
Our solution is purpose-built for development teams working with complex, interconnected data—whether structured or unstructured—in real-time or interactive user environments.
-
The system supports the OpenCypher query language with proprietary enhancements that streamline interactions with graph data, and its efficient graph traversal and query capabilities render it well-suited for production environments.
- Graph Path: If you're interested in utilizing 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, jump directly to the GraphRAG SDK section [1].
- Adopts the Property Graph Model
- Supports OpenCypher query language with proprietary extensions
- Offers Full-Text Search, Vector Similarity & Numeric indexing.
- Interacts via either RESP and Bolt protocols
- Graphs represented as sparse adjacency matrices
- Supports GraphRAG with the GraphRAG SDK for advanced graph reasoning and generative AI tasks.
Launch an instance using docker, or use FalkorDB Clouds
docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latestOnce loaded you can interact with FalkorDB using any of the supported client libraries
Here we'll use FalkorDB Python client 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.
{% capture python_code %} from falkordb import FalkorDB
db = FalkorDB(host='localhost', port=6379)
g = db.select_graph('MotoGP')
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'})""")
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"
res = g.query("""MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'}) RETURN count(r)""")
print(res.result_set[0][0]) # Prints: 1 {% endcapture %}
{% capture javascript_code %} 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'}))
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() {% endcapture %}
{% capture java_code %} 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<String, Object> 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();
}
} {% endcapture %}
{% capture rust_code %} 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(())
} {% endcapture %}
{% include code_tabs.html id="code_tabs_0" python=python_code javascript=javascript_code java=java_code rust=rust_code %}
For additional demos please see visit Demos.
Language-specific clients have been written by the community and the FalkorDB team. The full list and links can be found on the Clients page.
When loading large graphs from CSV files, we recommend using falkordb-bulk-loader
Got questions? Please contact us at the FalkorDB forum.
FalkorDB is licensed under the the Server Side Public License v1 (SSPLv1).